作者： ethan

Prometheus本地部署

在本地mac上，进行Prometheus服务的部署，便于开发、学习和测试。

下载镜像

docker pull prom/prometheus:v2.27.1

配置

mkdir -p ~/Ethan/Docker/prometheus-2.27.1
cd ~/Ethan/Docker/prometheus-2.27.1

增加配置文件:

global:
  # 拉取时间间隔, 默认1m
  scrape_interval: 1m

  # 拉取超时时间, 默认10s
  scrape_timeout: 10s

  # 评估规则的时间间隔, 默认1m
  evaluation_interval: 1m

# 抓取对象配置
scrape_configs:
  - job_name: 'node_test'

    # 采集服务的地址 targets, 可逗号间隔配置多个
    static_configs:
    - targets: ['10.252.187.163:8080']

    # 采集的路径
    metrics_path: '/test/prometheus/metrics'

启动镜像

docker run -d \
--name prometheus \
-p 9090:9090 \
-v /Users/ethanxu/Ethan/Docker/prometheus-2.8.0/prometheus.yml:/etc/prometheus/prometheus.yml \
prom/prometheus:v2.8.0 \
--config.file=/etc/prometheus/prometheus.yml

访问

http://127.0.0.1:9090/graph

查看 targets ，可以看到 job 处于 UP 状态，说明配置成功了。

2021年6月4日

最长回文子串 – LeetCode5

题目

给你一个字符串xa0s，找到xa0sxa0中最长的回文子串。

示例1:
输入：s = "babad" 
输出："bab" 
解释："aba" 同样是符合题意的答案。

示例 2：
输入：s = "cbbd" 
输出："bb"

示例 3：
输入：s = "a"
输出："a"

示例 4：
输入：s = "ac"
输出："a"

题解

golang:

func longestPalindrome(s string) string {
	if s == "" {
		return ""
	}

	start, end := 0, 0
	for i := 0; i < len(s); i++ {
		left1, right1 := expandAroundCenter(s, i, i)
		left2, right2 := expandAroundCenter(s, i, i + 1)
		if right1 - left1 > end - start {
			start, end = left1, right1
		}
		if right2 - left2 > end - start {
			start, end = left2, right2
		}
	}
	return s[start:end + 1]
}

func expandAroundCenter(s string, left int, right int) (int, int) {
	for ; left >= 0 && right < len(s) && s[left] == s[right]; left, right = left -1, right + 1 {}
	return left + 1, right - 1
}

golang之排序算法

下面我们来看下golang实现的排序算法。

快速排序

func QuickSort(arr []int) []int {
	length := len(arr)
	if length <= 1 {
		return arr
	}
	mid := arr[0]
	low, high := make([]int, 0), make([]int, 0)
	for i := 1; i < length; i++ {
		if arr[i] > mid {
			high = append(high, arr[i])
		} else {
			low = append(low, arr[i])
		}
	}

	lowSlice := QuickSort(low)
	highSlice := QuickSort(high)

	return append(append(lowSlice, mid), highSlice...)
}

归并排序

func mergeSort(arr []int) []int {
	length := len(arr)
	if length <= 1 {
		return arr
	}

	mid := length / 2
	left := mergeSort(arr[:mid])
	right := mergeSort(arr[mid:])

	return merge(left, right)
}
func merge(left []int, right []int) []int {
	leftLen := len(left)
	rightLen := len(right)
	i, j := 0, 0
	tmp := make([]int, 0)
	for ;i < leftLen && j < rightLen; {
		if left[i] < right[j] {
			tmp = append(tmp, left[i])
			i++
		} else {
			tmp = append(tmp, right[j])
			j++
		}
	}
	if i < leftLen {
		tmp = append(tmp, left[i:]...)
	} else if j < rightLen {
		tmp = append(tmp, right[j:]...)
	}
	return tmp
}

2021年5月11日

Elasticsearch更新mapping

es更新mapping是一个非常规的操作，下面是操作执行脚本:

from elasticsearch import Elasticsearch
from elasticsearch import helpers

esIp = "127.0.0.1"
esPort = "9200"

fromIndex = "old_index"
targetIndex = "new_index"

new_mapping = {"mappings": {"_doc": {"properties": {"id": {"type": "long"}, "title": {"type": "text", "analyzer": "ik_max_word", "search_analyzer": "ik_smart", "fields": {"keyword": {"type": "keyword", "ignore_above": 256}}}, "content": {"type": "text", "analyzer": "ik_max_word", "search_analyzer": "ik_smart", "fields": {"keyword": {"type": "keyword", "ignore_above": 256}}}}}}}

bulk_read = 1000
scroll = "5m"

# 连接elasticsearch
es = Elasticsearch([esIp], http_auth=("my_name", "my_pwd"), port=esPort)

# 创建新索引
es.indices.create(index=targetIndex, body=new_mapping)
helpers.reindex(client=es, source_index=fromIndex, target_index=targetIndex, target_client=es, query={"query": {"match_all": {}}}, chunk_size=bulk_read)

# 删除旧索引
es.indices.delete(fromIndex)

# 索引设置别名
es.indices.put_alias(index=targetIndex, name=fromIndex)

2021年4月29日

elasticsearch 精确匹配搜索(高准确度)
elasticsearch可以说是目前应用非常广泛的搜索引擎了，然而如果想要能够完全的满足检索的需求，还是有些需要注意的点的。

ik分词器，是elasticsearch检索中文时最常用的分词器。其有两种分词模式:

ik_max_word

会将文本做最细粒度的拆分，比如:

中华人民共和国人民大会堂 => 中华人民共和国、中华人民、中华、华人、人民共和国、人民、共和国、大会堂、大会、会堂

ik_smart

会做最粗粒度的拆分，比如:

中华人民共和国人民大会堂 => 中华人民共和国、人民大会堂

常规的最常用的使用方式就是，数据插入存储时用 ik_max_word模式分词，而检索时，用ik_smart模式分词，即：索引时最大化的将文章内容分词，搜索时更精确的搜索到想要的结果。

模糊匹配

mapping:
```
{"_doc":{"properties":{"content":{"type":"text","analyzer":"ik_max_word","search_analyzer":"ik_smart"}}}}
```
query:
```
{"bool":{"must":[{"match_phrase":{"content":"\u72fc\u5d3d"}}]}}
```
该检索能够满足大部分的检索需求，也是最常用的检索方式

模糊匹配&精确匹配

有时候，检索不仅需要支持模糊匹配，还需要支持完全匹配

mapping:
```
{"_doc":{"properties":{"content":{"type":"text","analyzer":"ik_max_word","search_analyzer":"ik_smart","fields":{"keyword":{"type":"keyword","ignore_above":256}}}}}}
```
通过给字段增加fileds “keyword”, 类型为keyword, 则该fields就可以通过 content.keyword 访问

query:
```
{"bool":{"must":[{"term":{"content.keyword":"\u6211\u559c\u6b22"}}]}}
```
通过以上方式则可以实现精准匹配

解决因分词问题导致用一些词检索不到数据的情况

上文我们讲过，索引是用ik_max_word分词，检索时用ik_smart分词，可以说，ik_smart的分词结果是ik_max_word分词结果的一个子集，那么理论上来讲，肯定是能够检索到数据的，那么为什么有时会检索不到呢？

对此官方网站对match_phrase的解释如下：

Like the match query, the match_phrase query first analyzes the query string to produce a list of terms. It then searches for all the terms, but keeps only documents that contain all of the search terms, in the same positions relative to each other.

意思就是说用match_phrase查找时，查找分词器分出的词的位置和要建索引时分出的词的相对位置一样。

例如:

原文：我喜欢一家四口的生活

ik_max_word分词结果

分词位置
我 0
喜欢 1
一家 2
一 3
家 4
四口 5
四 6
口 7

检索词: 一家四口

ik_smart分词结果

分词位置
一家 0
四口 1

从上面可以看出，查找时ik_smart将语句分为了一家和四口两个词，位置分别为 0 和 1 ，而ik_max_word建索引时，一家和四口的位置分别是 2 和 5，一个位置相邻，一个位置不相邻，在match_phrase看来，这种是不匹配的，所以用ik_smart分词短语时无法查到或者查全数据。

为了解决match_phrase这个问题，我们可以辅以使用standard分词器。

standard分词器大家都比较熟，针对于汉字就是一个一个分，这种肯定是可以查全的。但一个一个字分的话，每个字对应的文档集合非常多，如果数据量达到了百亿，在求交集，计算距离时，效果非常差。而这里我们可以将其跟ik分词器配合使用，既利用ik分词器的优势，又可以利用standard分词器进行兜底。

但是，此时还有一个问题，就是standard分词只是针对单个字的分词，ik_max_word分出了很多词，如果有“好人”，“好人的”这种分词结果，那么搜索“好人”，match_phrase仅能够搜索出“好人”对应的结果，同样符合预期的“好人的”的结果是检索不到的。

针对这种情况，我们利用match_phrase_prefix代替match_phrase，match_phrase_prefix 与 match_phrase查询类似，但是会对最后一个Token在倒排序索引列表中进行通配符搜索。即match_phrase_prefix将会找到“好人”，“好人的”对应的结果。

mapping:
```
{"_doc":{"properties":{"content":{"type":"text","analyzer":"ik_max_word","search_analyzer":"ik_smart","fields":{"keyword":{"type":"keyword","ignore_above":256},"standard":{"type":"text","analyzer":"standard"}}}}}}
```
query:
```
{"query":{"bool":{"must":[{"bool":{"should":[{"match_phrase_prefix":{"content":"\u6211\u559c\u6b22"}},{"match_phrase_prefix":{"content.standard":"\u6211\u559c\u6b22"}}]}}]}}}
```
总结

以上就是elasticsearch的检索相关知识，因为es修改mapping相当的麻烦，所以大家在创建索引时，一定要尽可能的将mapping考虑周全，避免之后的修改。

当然，为了以后万一修改的时候减小成本，大家创建索引后，尽量同时创建别名，然后利用别名访问该索引，这样之后就可以通过修改别名指向，从而无缝替换旧索引，不影响线上服务。

附录

如果仅仅是给索引字段增加fields，是不需要重建索引的，可以直接修改mapping:
```
curl -H "Content-Type: application/json;" -X POST 'http://127.0.0.1:9200/my_index/_doc/_mapping?pretty' -d '
{"_doc":{"properties":{"title":{"type":"text","analyzer":"ik_max_word","search_analyzer":"ik_smart","fields":{"keyword":{"type":"keyword","ignore_above":256}}},"content":{"type":"text","analyzer":"ik_max_word","search_analyzer":"ik_smart","fields":{"keyword":{"type":"keyword","ignore_above":256}}}}}}
'
```
修改完mapping后，新的数据就会按照新的mapping来走了，如果想要历史数据也同步新的mapping的话，则利用_update_by_query更新即可:
```
curl -H "Content-Type: application/json;" -X POST 'http://127.0.0.1:9200/my_index/_update_by_query?conflicts=proceed'
```
更新时间跟数据量的多少有关，数据越多，则更新所需时间越长。
2021年4月28日

明确mysql整型字段取值范围

mysql中存储整数，有很多种类型供选择，选择合适的类型，无论是对存储空间的合理使用，检索性能的提高等都有很好的便利，下面就由我们来一起明确下。

数据类型	字节数	有符号	无符号 unsigned
tinyint	1	-128~127 (-2^8 ~ 2^8 – 1)	0~255 (2^9 – 1)
smallint	2	-32,768~32,767 (-2^15 ~ 2^15 – 1)	0~65535 (2^16 – 1)
mediumint	3	-8,388,608~8,388,607(-2^23 ~ 2^23 – 1)	0~16777215(2^24 – 1)
int / integer	4	-2,147,483,648~2,147,483,647(-2^31 ~ 2^31 – 1)	0~4294967295(2^32 – 1)
bigint	8	-9,223,372,036,854,775,808~9,223,372,036,854,775,807(-2^63 ~ 2^63 – 1)	0~18446744073709551615(2^64 – 1)

2021年4月25日

golang并发控制

golang对于并发的支持可以说是最好的，也是我们之所以采用go语言进行编程的一个重要的因素。

golang的并发控制，主要有以下几种方式:

Channel

func Process(ch chan<- int)  {
	// do something
	time.Sleep(time.Second)

	ch <- 1
}

func TestOther(t *testing.T) {
	// 有几个协程，就需要创建包含多少元素的切片
	channels := make([]chan int, 10)

	for i := 0; i < 10; i++ {
		channels[i] = make(chan int)
		go Process(channels[i])
	}

	for i, ch := range channels {
		<-ch
		fmt.Printf("Routine %d quit \n", i)
	}
}

优点是实现简单，缺点是当需要大量创建协程时就需要有相同数量的channel，而且对于子协程继续派生出来的协程不方便控制。

WaitGroup

func Process(wg *sync.WaitGroup, i int)  {
	defer wg.Done()

	// do something
	time.Sleep(time.Second)

	fmt.Printf("Routine %d quit \n", i)
}

func TestOther(t *testing.T) {
	wg := sync.WaitGroup{}

	wg.Add(10)

	for i := 0; i < 10; i++ {
		go Process(&wg, i)
	}
	wg.Wait()
	fmt.Printf("all Goroutine quit \n")
}

WaitGroup是Golang应用开发过程中经常使用的并发控制技术。WaitGroup，可理解为Wait-Goroutine-Group，即等待一组goroutine结束。比如某个goroutine需要等待其他几个goroutine全部完成，那么使用WaitGroup可以轻松实现。

Add()操作必须早于Wait(), 否则会panic
Add()设置的值必须与实际等待的goroutine个数一致，否则会panic

2021年4月7日

golang 并发 append
go中，切片可以算是我们最常用的结构之一，但是如果不注意的话，在并发情况下，对同一个切片进行append，极有可能会造成线程不安全的情况。

非线程安全现象

如，以下例子:
```
func TestOther(t *testing.T) {
	testMap := []int{1,2,3,4}

	wg := sync.WaitGroup{}
	wg.Add(4)
	
	m := make([]int, 0)
	
	for _, v := range testMap {
		go func(v int) {
			defer wg.Done()

			m = append(m, v)
		}(v)
	}
	wg.Wait()

	t.Log(m)
}
```
以上代码，不同次运行时，输出以下这类不符合预期的结果：

这就是因为线程不安全导致的 (实际业务中，可以通过 go run -race main.go 进行检测程序的安全性)

原因分析

slice的数据结构:
```
type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}
```
slice结构示意图

使用append向Slice追加元素时，如果Slice空间不足，将会触发Slice扩容，扩容实际上重新一配一块更大的内存，将原Slice数据拷贝进新Slice，然后返回新Slice，扩容后再将数据追加进去。

在并发情况下，如果该slice始终空间不足，那么其是线程安全的，因为每次append实际都是新生成的内存，不存在抢占的情况。但是，当slice空间充足，也即是cap>len, 有剩余的空间时，比如说，下一个空闲内存是a, 那么并发情况下，就会出现多个线程抢占往a中写数据的情况。
```
slice扩容遵从以下原则:
如果原Slice容量小于1024，则新Slice容量将扩大为原来的2倍；
如果原Slice容量大于等于1024，则新Slice容量将扩大为原来的1.25倍；
```
所以，根据以上的原则，在程序运行后，是很容易就会出现有空闲空间的情况，也就会造成线程不安全的产生。

解决办法

针对内存占用，我们最直接简单的办法就是给内存加锁，如下:
```
func TestOther(t *testing.T) {
	testMap := []int{1,2,3,4}

	wg := sync.WaitGroup{}
	wg.Add(4)
	
	m := make([]int, 0)
	
	var lock sync.Mutex
	
	for _, v := range testMap {
		go func(v int) {
			defer wg.Done()

			lock.Lock()
			m = append(m, v)
			lock.Unlock()
			
		}(v)
	}
	wg.Wait()

	t.Log(m)
}
```
运行结果:

通过内存加锁，确保，同一时刻，只有一个线程对该块内存进行append操作，这就从根源上避免了抢占的问题。
2021年3月30日
golang内存分配管理

基础

为了方便自主的管理内存，golang的做法是，先向系统申请一块大的内存，然后将其分割成一个个小块，通过自己的内存分配算法来进行管理。

预申请的内存

预申请的内存划分为spans、bitmap、arena三部分。其中arena即为所谓的堆区，应用中需要的内存从这里分配。其中spans和bitmap是为了管理arena区而存在的。

arena的大小为512G，为了方便管理把arena区域划分成一个个的page，每个page为8KB,一共有512GB/8KB个页；

spans区域存放span的指针，每个指针对应一个page，所以span区域的大小为(512GB/8KB)*指针大小8byte = 512M；

bitmap区域大小也是通过arena计算出来，不过主要用于GC。

mheap

系统通过mheap来管理预申请的内存.

mheap内存管理示意图如下：

central

central是全局资源，为多个线程服务，当某个线程内存不足时会向central申请，当某个线程释放内存时又会回收进central。

cache

cache作为线程的私有资源为单个线程服务。

mcache和span的对应关系如下图所示：

span

span是内存管理的基本单位,每个span用于管理特定的class对象, 跟据对象大小，span将一个或多个页拆分成多个块进行管理。

golang内存分配 span

内存分配图解

golang内存分配

2021年3月23日