**文章目录：**
[TOC]

## 前言

如果你有一个任务可以分解成多个子任务进行处理，同时每个子任务没有先后执行顺序的限制，等到全部子任务执行完毕后，再进行下一步处理。这时每个子任务的执行可以并发处理，这种情景下适合使用 `sync.WaitGroup`。

虽然 `sync.WaitGroup` 使用起来比较简单，但是一不留神很有可能踩到坑里。

## sync.WaitGroup 正确使用

比如，有一个任务需要执行 3 个子任务，那么可以这样写：

```
func main() {
	var wg sync.WaitGroup

	wg.Add(3)

	go handlerTask1(&wg)
	go handlerTask2(&wg)
	go handlerTask3(&wg)

	wg.Wait()

	fmt.Println("全部任务执行完毕.")
}

func handlerTask1(wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Println("执行任务 1")
}

func handlerTask2(wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Println("执行任务 2")
}

func handlerTask3(wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Println("执行任务 3")
}
```

执行输出：

```
执行任务 3
执行任务 1
执行任务 2
全部任务执行完毕.
```

## sync.WaitGroup 闭坑指南

### 01

```
// 正确
go handlerTask1(&wg)

// 错误
go handlerTask1(wg)
```

执行子任务时，使用的 `sync.WaitGroup` 一定要是 `wg` 的引用类型！

### 02

注意不要将 `wg.Add()` 放在 `go handlerTask1(&wg)` 中！

例如：

```
// 错误
var wg sync.WaitGroup

go handlerTask1(&wg)

wg.Wait()

...

func handlerTask1(wg *sync.WaitGroup) {
	wg.Add(1)
	defer wg.Done()
	fmt.Println("执行任务 1")
}
```

注意 `wg.Add()` 一定要在 `wg.Wait()` 执行前执行！

### 03

注意 `wg.Add()` 和 `wg.Done()` 的计数器保持一致！其实 `wg.Done()` 就是执行的 `wg.Add(-1)` 。

## 小结

`sync.WaitGroup` 使用起来比较简单，一定要注意不要踩到坑里。

其实 `sync.WaitGroup` 使用场景比较局限，仅适用于等待全部子任务执行完毕后，再进行下一步处理，如果需求是当第一个子任务执行失败时，通知其他子任务停止运行，这时 `sync.WaitGroup` 是无法满足的，需要使用到通知机制（`channel`）。

以上，希望对你能够有所帮助。

## 推荐阅读

- [Go - 使用 sync.Map 解决 map 并发安全问题](https://mp.weixin.qq.com/s/WOuzCJWeuH41qoUP4_zRQA)
- [Go - 基于逃逸分析来提升程序性能](https://mp.weixin.qq.com/s/gAz87qPA8sBJMeq6MZbqwg)
- [Go - 使用 sync.Pool 来减少 GC 压力](https://mp.weixin.qq.com/s/0NVp59uI8h9WTp68wtb7XQ)
- [Go - 使用 options 设计模式](https://mp.weixin.qq.com/s/jvSbZ0_g_EFqaR2TmjjO8w)
- [Go - 两个在开发中需注意的小点](https://mp.weixin.qq.com/s/-QCG61vh6NVJUWz6tOY7Gw)

21-使用 sync

咱们平时是这样使用 `grpc.Dial` 方法的，比如：

```
conn, err := grpc.Dial("127.0.0.1:8000",
		grpc.WithChainStreamInterceptor(),
		grpc.WithInsecure(),
		grpc.WithBlock(),
		grpc.WithDisableRetry(),
	)
```

咱们怎么能写出类似这样的调用方式，它是怎么实现的？

这篇文章咱们写一个 Demo，其实很简单，一步步往下看。

## 一

`opts …DialOption`，这个是不定参数传递，参数的类型为 `DialOption`，不定参数是指函数传入的参数个数为不定数量，可以不传，也可以为多个。

写一个不定参数传递的方法也很简单，看看下面这个方法 1 + 2 + 3 = 6。

```
func Add(a int, args ...int) (result int) {
	result += a
	for _, arg := range args {
		result += arg
	}
	return
}

fmt.Println(Add(1, 2, 3))

// 输出 6
```

其实平时我们用的 `fmt.Println()`、`fmt.Sprintf()` 都属于不定参数的传递。

## 二

`WithInsecure()`、`WithBlock()` 类似于这样的 With 方法，其实作用就是修改 `dialOptions` 结构体的配置，之所以这样写我个人认为是面向对象的思想，当配置项调整的时候调用方无需修改。

## 场景

咱们模拟一个场景，使用 `不定参数` 和 `WithXXX` 这样的写法，写个 Demo，比如我们要做一个从附近找朋友的功能，配置项有：性别、年龄、身高、体重、爱好，我们要找性别为女性，年龄为30岁，身高为160cm，体重为55kg，爱好为爬山的人，希望是这样的调用方式：

```
friends, err := friend.Find("附近的人",
		friend.WithSex(1),
		friend.WithAge(30),
		friend.WithHeight(160),
		friend.WithWeight(55),
		friend.WithHobby("爬山"))
```

## 代码实现

```
// option.go

package friend

import (
	"sync"
)

var (
	cache = &sync.Pool{
		New: func() interface{} {
			return &option{sex: 0}
		},
	}
)

type Option func(*option)

type option struct {
	sex    int
	age    int
	height int
	weight int
	hobby  string
}

func (o *option) reset() {
	o.sex = 0
	o.age = 0
	o.height = 0
	o.weight = 0
	o.hobby = ""
}

func getOption() *option {
	return cache.Get().(*option)
}

func releaseOption(opt *option) {
	opt.reset()
	cache.Put(opt)
}

// WithSex setup sex, 1=female 2=male
func WithSex(sex int) Option {
	return func(opt *option) {
		opt.sex = sex
	}
}

// WithAge setup age
func WithAge(age int) Option {
	return func(opt *option) {
		opt.age = age
	}
}

// WithHeight set up height
func WithHeight(height int) Option {
	return func(opt *option) {
		opt.height = height
	}
}

// WithWeight set up weight
func WithWeight(weight int) Option {
	return func(opt *option) {
		opt.weight = weight
	}
}

// WithHobby set up Hobby
func WithHobby(hobby string) Option {
	return func(opt *option) {
		opt.hobby = hobby
	}
}

```

```
// friend.go

package friend

import (
	"fmt"
)

func Find(where string, options ...Option) (string, error) {
	friend := fmt.Sprintf("从 %s 找朋友\n", where)

	opt := getOption()
	defer func() {
		releaseOption(opt)
	}()

	for _, f := range options {
		f(opt)
	}

	if opt.sex == 1 {
		sex := "性别：女性"
		friend += fmt.Sprintf("%s\n", sex)
	}
	if opt.sex == 2 {
		sex := "性别：男性"
		friend += fmt.Sprintf("%s\n", sex)
	}

	if opt.age != 0 {
		age := fmt.Sprintf("年龄：%d岁", opt.age)
		friend += fmt.Sprintf("%s\n", age)
	}

	if opt.height != 0 {
		height := fmt.Sprintf("身高：%dcm", opt.height)
		friend += fmt.Sprintf("%s\n", height)
	}

	if opt.weight != 0 {
		weight := fmt.Sprintf("体重：%dkg", opt.weight)
		friend += fmt.Sprintf("%s\n", weight)
	}

	if opt.hobby != "" {
		hobby := fmt.Sprintf("爱好：%s", opt.hobby)
		friend += fmt.Sprintf("%s\n", hobby)
	}

	return friend, nil
}

```

```
// main.go

package main

import (
	"demo/friend"
	"fmt"
)

func main() {
	friends, err := friend.Find("附近的人",
		friend.WithSex(1),
		friend.WithAge(30),
		friend.WithHeight(160),
		friend.WithWeight(55),
		friend.WithHobby("爬山"))

	if err != nil {
		fmt.Println(err)
	}

	fmt.Println(friends)
}

```

## 输出

```
从 附近的人 找朋友
性别：女性
年龄：30岁
身高：160cm
体重：55kg
爱好：爬山
```


14-学习 grpc

**文章目录：**
[TOC]

## 前言

在 `Golang` 中 `map` 不是并发安全的，自 1.9 才引入了 `sync.Map` ，`sync.Map` 的引入确实解决了 `map` 的并发安全问题，不过 `sync.Map` 却没有实现 `len()` 函数，如果想要计算 `sync.Map` 的长度，稍微有点麻烦，需要使用 `Range` 函数。

## map 并发操作出现问题

```
func main() {
	demo := make(map[int]int)

	go func() {
		for j := 0; j < 1000; j++ {
			demo[j] = j
		}
	}()

	go func() {
		for j := 0; j < 1000; j++ {
			fmt.Println(demo[j])
		}
	}()

	time.Sleep(time.Second * 1)
}
```

执行输出：

```
fatal error: concurrent map read and map write
```

## sync.Map 解决并发操作问题

```
func main() {
	demo := sync.Map{}

	go func() {
		for j := 0; j < 1000; j++ {
			demo.Store(j, j)
		}
	}()

	go func() {
		for j := 0; j < 1000; j++ {
			fmt.Println(demo.Load(j))
		}
	}()

	time.Sleep(time.Second * 1)
}
```

执行输出：

```
<nil> false
1 true

...

999 true
```

## 计算 map 长度

```
func main() {
	demo := make(map[int]int)

	for j := 0; j < 1000; j++ {
		demo[j] = j
	}

	fmt.Println("len of demo:", len(demo))
}
```

执行输出：

```
len of demo: 1000
```

## 计算 sync.Map 长度

```
func main() {
	demo := sync.Map{}
	
	for j := 0; j < 1000; j++ {
		demo.Store(j, j)
	}

	lens := 0
	demo.Range(func(key, value interface{}) bool {
		lens++
		return true
	})

	fmt.Println("len of demo:", lens)
}
```

执行输出：

```
len of demo: 1000
```

## 小结

1. `Load` 加载 key 数据
2. `Store` 更新或新增 key 数据
3. `Delete` 删除 key 数据
4. `Range` 遍历数据
5. `LoadOrStore` 如果存在 key 数据则返回，反之则设置
6. `LoadAndDelete` 如果存在 key 数据则删除

以上，希望对你能够有所帮助。

## 推荐阅读

- [Go - 基于逃逸分析来提升程序性能](https://mp.weixin.qq.com/s/gAz87qPA8sBJMeq6MZbqwg)
- [Go - 使用 sync.Pool 来减少 GC 压力](https://mp.weixin.qq.com/s/0NVp59uI8h9WTp68wtb7XQ)
- [Go - 使用 options 设计模式](https://mp.weixin.qq.com/s/jvSbZ0_g_EFqaR2TmjjO8w)
- [Go - json.Unmarshal 遇到的小坑](https://mp.weixin.qq.com/s/ykZCZb9IAXJaKAx_cO7YjA)
- [Go - 两个在开发中需注意的小点](https://mp.weixin.qq.com/s/-QCG61vh6NVJUWz6tOY7Gw)

20-使用 sync

**文章目录：**
[TOC]

## 前言

`sync.Pool` 是临时对象池，存储的是临时对象，不可以用它来存储 `socket` 长连接和数据库连接池等。

`sync.Pool` 本质是用来保存和复用临时对象，以减少内存分配，降低 GC 压力，比如需要使用一个对象，就去 Pool 里面拿，如果拿不到就分配一份，这比起不停生成新的对象，用完了再等待 GC 回收要高效的多。

## sync.Pool

`sync.Pool` 的使用很简单，看下示例代码：

```
package student

import (
	"sync"
)

type student struct {
	Name string
	Age  int
}

var studentPool = &sync.Pool{
	New: func() interface{} {
		return new(student)
	},
}

func New(name string, age int) *student {
	stu := studentPool.Get().(*student)
	stu.Name = name
	stu.Age = age
	return stu
}

func Release(stu *student) {
	stu.Name = ""
	stu.Age = 0
	studentPool.Put(stu)
}
```

当使用 `student` 对象时，只需要调用 `New()` 方法获取对象，获取之后使用 `defer` 函数进行释放即可。

```
stu := student.New("tom", 30)
defer student.Release(stu)

// 业务逻辑
...

```

关于 `sync.Pool` 里面的对象具体是什么时候真正释放，是由系统决定的。

## 小结

1. 一定要注意存储的是临时对象！
2. 一定要注意 `Get` 后，要调用 `Put` ！

以上，希望对你能够有所帮助。

## 推荐阅读

- [Go - 使用 options 设计模式](https://mp.weixin.qq.com/s/jvSbZ0_g_EFqaR2TmjjO8w)
- [Go - json.Unmarshal 遇到的小坑](https://mp.weixin.qq.com/s/ykZCZb9IAXJaKAx_cO7YjA)
- [Go - 两个在开发中需注意的小点](https://mp.weixin.qq.com/s/-QCG61vh6NVJUWz6tOY7Gw)
- [Go - time.RFC3339 时间格式化](https://mp.weixin.qq.com/s/1pFVaMaWItp8zCXotQ9iBg)

18-使用 sync

签名验证是为了保证接口安全和识别调用方身份，同时还需要满足以下几点：

- 可变性：每次的签名必须是不一样的。
- 时效性：每次请求的时效性，过期作废。
- 唯一性：每次的签名是唯一的。
- 完整性：能够对传入数据进行验证，防止篡改。

签名规则大同小异，根据自己的业务情况进行制定即可。

签名过程中我们会用到的几种算法，接下来分享一下每个算法的基准测试，可能会存在误差，供大家参考。

## MD5 单向散列加密

```
func BenchmarkEncrypt(b *testing.B) {
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		New().Encrypt("123456")
	}
}

// 输出
goos: darwin
goarch: amd64
pkg: github.com/xinliangnote/go-gin-api/pkg/md5
BenchmarkEncrypt-12    	10000000	       238 ns/op
PASS
```

## AES 对称加密

```
func BenchmarkEncryptAndDecrypt(b *testing.B) {
	b.ResetTimer()
	aes := New(key, iv)
	for i := 0; i < b.N; i++ {
		encryptString, _ := aes.Encrypt("123456")
		aes.Decrypt(encryptString)
	}
}

// 输出
goos: darwin
goarch: amd64
pkg: github.com/xinliangnote/go-gin-api/pkg/aes
BenchmarkEncryptAndDecrypt-12    	 1000000	      1009 ns/op
PASS
```

## RSA 非对称加密

```
func BenchmarkEncryptAndDecrypt(b *testing.B) {
	b.ResetTimer()
	rsaPublic := NewPublic(publicKey)
	rsaPrivate := NewPrivate(privateKey)
	for i := 0; i < b.N; i++ {
		encryptString, _ := rsaPublic.Encrypt("123456")
		rsaPrivate.Decrypt(encryptString)
	}
}

// 输出
goos: darwin
goarch: amd64
pkg: github.com/xinliangnote/go-gin-api/pkg/rsa
BenchmarkEncryptAndDecrypt-12    	    1000	   1345384 ns/op
PASS
```

## 最后

JWT 的签名验证也使用过，分享一下 `JWT` 的基准测试，使用的是 `jwt.SigningMethodHS256` 方法。

```
func BenchmarkSignAndParse(b *testing.B) {
	b.ResetTimer()
	token := New(secret)
	for i := 0; i < b.N; i++ {
		tokenString, _ := token.Sign(123456789, "xinliangnote")
		token.Parse(tokenString)
	}
}

// 输出
goos: darwin
goarch: amd64
pkg: github.com/xinliangnote/go-gin-api/pkg/token
BenchmarkSignAndParse-12    	  200000	     11749 ns/op
PASS
```

以上代码在 `go-gin-api` 项目中，地址：github.com/xinliangnote/go-gin-api

