go等待一组协程结束的操作方式

Go提供了sync包和channel来解决协程同步和通讯。

sync.WaitGroup是等待一组协程结束，sync.WaitGroup只有3个方法，Add()添加一个计数，Done()减去一个计数，Wait()阻塞直到所有任务完成。

package main
import (
"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")
}

运行结果：

task... 9

task... 4

task... 6

task... 0

task... 7

task... 5

task... 1

task... 2

task... 8

task... 3

over

利用缓冲信道channel协程之间通讯，其阻塞等待功能实现等待一组协程结束，不能保证其goroutine按照顺序执行

package main
import (
 "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")
}

运行结果：

task... 9

task... 0

task... 1

task... 2

task... 6

task... 7

task... 3

task... 4

task... 8

task... 5

over

利用无缓冲的信道channel协程之间通讯，其阻塞等待功能实现等待一组协程结束，保证了其goroutine按照顺序执行

package main
import (
 "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要做的是，通过通信来共享内存。

每次通信进行成对通信，当main向协程发送一个写channel时，同时也等待协程返回一个读channel。

这两个channel一定是成对的，所以构造一个结构体

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，先小写再大写的顺序

如果这样顺序执行，还要协程干啥

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
}

这样的话，先打印小写，再打印大写，但是大小写时顺序不固定

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进行树的遍历

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)
 

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程网。如有错误或未考虑完全的地方，望不吝赐教。