go提供了sync包和channel来解决协程同步和通讯。
方式1:sync.WaitGroup是等待一组协程结束，sync.WaitGroup只有3个方法，Add()添加一个计数，Done()减去一个计数，Wait()阻塞直到所有任务完成。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package mainimport ( "fmt" "sync" "time")var wg sync.WaitGroup //定义一个同步等待的组func task(i int){ fmt.Println("task...",i) //耗时操作任务，网络请求，读取文件 time.Sleep(time.Second) wg.Done() //减去一个计数}func main(){ for i:= 0;i<10;i++{ wg.Add(1) //添加一个计数 go task(i) } wg.Wait() //阻塞直到所有任务完成 fmt.Println("over")} |
运行结果：
方式2:task... 9
task... 4
task... 6
task... 0
task... 7
task... 5
task... 1
task... 2
task... 8
task... 3
over
利用缓冲信道channel协程之间通讯，其阻塞等待功能实现等待一组协程结束，不能保证其goroutine按照顺序执行
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package mainimport ( "fmt")var ch = make(chan int,10)func task(i int){ fmt.Println("task...",i) ch <- i}func main(){ for i:= 0;i<10;i++{ go task(i) } for i:= 0;i<10;i++{ <- ch } fmt.Println("over")} |
运行结果：
方式3:task... 9
task... 0
task... 1
task... 2
task... 6
task... 7
task... 3
task... 4
task... 8
task... 5
over
利用无缓冲的信道channel协程之间通讯，其阻塞等待功能实现等待一组协程结束，保证了其goroutine按照顺序执行
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package mainimport ( "fmt" "time")var ch = make(chan int)func task(i int){ fmt.Println("task...",i) time.Sleep(time.Second) <- ch}func main(){ for i:= 0;i<10;i++{ go task(i) ch <- i } fmt.Println("over")} |
运行结果：
task... 0
task... 1
task... 2
task... 3
task... 4
task... 5
task... 6
task... 7
task... 8
task... 9
over
补充：Go中使用Channel等待所有协程结束
让main方法等待所有协程执行完毕再退出。可能一般思路是设置一个共有变量，然后通过修改这个变量的状态。这是通过共享变量来通信的方式，而go要做的是，通过通信来共享内存。
1. 按顺序执行每次通信进行成对通信，当main向协程发送一个写channel时，同时也等待协程返回一个读channel。
这两个channel一定是成对的，所以构造一个结构体
|
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
|
type worker struct { in chan int done chan bool} func chanDemo1(){ var workers [10]worker for i := 0; i < 10; i++ { workers[i] = createWorker1(i) } for i := 0; i < 10; i++ { workers[i].in <- 'a' + i <- workers[i].done } for i := 0; i < 10; i++ { workers[i].in <- 'A' + i <- workers[i].done } } func createWorker1(id int) worker { work := worker{ in: make(chan int), done: make(chan bool), } go func() { for { fmt.Printf("Work %d receiverd %c\n", id, <- work.in) work.done <- true } }() return work} func main(){ chanDemo1() fmt.Println("over")} |
这个执行结果完全是按照0-9，先小写再大写的顺序
如果这样顺序执行，还要协程干啥
2. 批量处理|
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
|
type worker struct { in chan int done chan bool} func chanDemo1(){ var workers [10]worker for i := 0; i < 10; i++ { workers[i] = createWorker1(i) } for i := 0; i < 10; i++ { workers[i].in <- 'a' + i } for _, worker := range workers { <- worker.done } for i := 0; i < 10; i++ { workers[i].in <- 'A' + i } for _, worker := range workers { <- worker.done }} func createWorker1(id int) worker { work := worker{ in: make(chan int), done: make(chan bool), } go func() { for { fmt.Printf("Work %d receiverd %c\n", id, <- work.in) work.done <- true } }() return work} |
这样的话，先打印小写，再打印大写，但是大小写时顺序不固定
3. 完全随机|
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
|
func chanDemo1(){ var workers [10]worker for i := 0; i < 10; i++ { workers[i] = createWorker1(i) } for i := 0; i < 10; i++ { workers[i].in <- 'a' + i } for i := 0; i < 10; i++ { workers[i].in <- 'A' + i } for _, worker := range workers { <- worker.done <- worker.done }} func createWorker1(id int) worker { work := worker{ in: make(chan int), done: make(chan bool), } go func() { for { fmt.Printf("Work %d receiverd %c\n", id, <- work.in) // 再开一个协程 go func() { work.done <- true}() } }() return work} |
这种方式就是完全随机了
使用channel进行树的遍历
|
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
|
func (node *Node) TraverseFunc(f func(*Node)){ if node == nil{ return } node.Left.TraverseFunc(f) f(node) node.Right.TraverseFunc(f)} func (node *Node) TraverseWithChannel() chan *Node{ out := make(chan *Node) go func() { node.TraverseFunc(func(node *Node) { out <- node }) close(out) }() return out} func main(){ var root Node root = Node{Value:3} root.Left = &Node{} root.Right = &Node{5,nil,nil} root.Right.Left = new(Node) root.Left.Right =&Node{6,nil,nil} root.Traverse() c:=root.TraverseWithChannel() maxNode := 0 for node := range c{ if node.Value > maxNode{ maxNode = node.Value } } fmt.Println("max node value:", maxNode) |
以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。如有错误或未考虑完全的地方，望不吝赐教。
原文链接：https://blog.csdn.net/cj_286/article/details/79538505
