Go 闭包解决多进程引用错误

一个包含 int 类型的切片，经过循环打印它们各自的值，可以非常方便的去遍历每个值的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import (
	"fmt"
)

func tasks() {
	l := []int{1, 2, 3, 4, 5}
	for _, p := range l {
		func(p int) {
			fmt.Println(p)
		}(p)
	}
}

func main() {
	tasks()
}

// 1
// 2
// 3
// 4
// 5

其中 fmt.Println(p) 可以看做是一个单独的任务，此时想多进程去执行加快任务的执行效率。

只需要加上 go 关键字和 sync 同步，但此时只是多次执行了最后一个任务，发生了并发捕获错误。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package main

import (
	"fmt"
	"sync"
)

func tasks() {
	l := []int{1, 2, 3, 4, 5}
	var wg sync.WaitGroup
	for _, p := range l {
		wg.Add(1)
		go func() {
			defer wg.Done()
			fmt.Println(p)
		}()
	}
	wg.Wait()
}

func main() {
	tasks()
}

// 5
// 5
// 5
// 5
// 5

在 Go 中，for _, p := range l 的循环变量 p 是在整个循环中共享的单一变量。每次迭代时，p 的值会被更新，但它的地址不会改变。匿名函数 func() 中捕获的是 p 的引用，而不是 p 的值。所以当 Goroutine 被执行时，它访问的是同一个 p 的地址，而此时循环可能已经完成，p 的值已经是最后一次迭代的结果 5。

因此可以使用闭包将每个循环的值作为一个独立的副本，显示传递变量，执行的任务就不会捕获错误。

1
2
3
4
5
6
7
8
9
10
11
12
func tasks() {
	l := []int{1, 2, 3, 4, 5}
	var wg sync.WaitGroup
	for _, p := range l {
		wg.Add(1)
		go func(t int) {
			defer wg.Done()
			fmt.Println(t)
		}(p)
	}
	wg.Wait()
}

更加常用的就是循环执行函数，通过闭包显示传递变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package main

import (
	"fmt"
	"sync"
)

func tasks() {
	functions := []func(){task1, task2, task3}
	var wg sync.WaitGroup
	for _, f := range functions {
		wg.Add(1)
		go func(t func()) {
			defer wg.Done()
			t()
		}(f)
	}
	wg.Wait()
}

func task1() {
	fmt.Println("执行task1")
}

func task2() {
	fmt.Println("执行task2")
}

func task3() {
	fmt.Println("执行task3")
}

func main() {
	tasks()
}

// 执行task3
// 执行task1
// 执行task2

模拟一个常见的场景，多进程执行函数，并写入数据，使用 Mutex 保护写入资源。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package main

import (
	"fmt"
	"sync"
)

type Res struct {
	TaskRes string
	Error   error
}

func tasks() map[string]Res {
	functions := []func() (string, string, error){task1, task2, task3}
	results := make(map[string]Res)
	var wg sync.WaitGroup
	var mu sync.Mutex
	for _, f := range functions {
		wg.Add(1)
		go func(t func() (string, string, error)) {
			defer wg.Done()
			n, r, err := t()
			mu.Lock()
			results[n] = Res{r, err}
			mu.Unlock()
		}(f)
	}
	wg.Wait()
	return results
}

func task1() (string, string, error) {
	return "task1", "task1成功", nil
}

func task2() (string, string, error) {
	return "task2", "task2成功", nil
}

func task3() (string, string, error) {
	return "task3", "task3成功", nil
}

func main() {
	m := tasks()
	for _, v := range m {
		fmt.Println(v.TaskRes)
	}
}

// task1成功
// task2成功
// task3成功