Golang中子goroutine与主协程同步的四种实现

06-12 Mark 962

###如何实现子goroutine与主线程的同步###
1、第一种方式：time.sleep():
```golang
package main

import (
		"fmt"
		"time"
)

func printCount() {
		for i := 0; i < 10; i++ {
			fmt.Println(i)
		}
}

func main() {
		go printCount()
		time.Sleep(time.Millisecond * 100)
}
```
这种方式没法正确预估goroutine执行的时间，很死板，不推荐使用。

2、第二种方式：使用channel机制，每个goroutine传一个channel进去然后往里写数据，在再主线程中读取这些channel，直到全部读到数据了子goroutine也就全部运行完了，那么主goroutine也就可以结束了。这种模式是子线程去通知主线程结束。
```golang
package main

import (
		"fmt"
)

func printCount(rs chan int) {
		defer close(rs)
		for i := 0; i < 10; i++ {
				rs <- i
		}
}

func main() {
		rs := make(chan int, 10)
		go printCount(rs)

for v := range rs {
				fmt.Println(v)
		}
}
```

3、第三种方式：使用context中cancel函数，这种模式是主线程去通知子线程结束。
```golang
package main

import (
		"context"
		"fmt"
)

func printCount(ctx context.Context) chan int {
		dst := make(chan int)
		n := 0
		go func() {
				for {
						select {
								case <-ctx.Done():
										return
								case dst <- n:
										n++
						}
				}
		}()
		return dst
}

func main() {
		ctx, cancel := context.WithCancel(context.Background())
		defer cancel()

intChan := printCount(ctx)
		for n := range intChan {
				if n == 9 {
						break
				}
				fmt.Println(n)
		}
}
```

4、第四种方式：sync.WaitGroup模式，Add方法设置等待子goroutine的数量，使用Done方法设置等待子goroutine的数量减1，当等待的数量等于0时，Wait函数返回。
```golang
package main

import (
		"fmt"
		"sync"
)

func printCount(wgp *sync.WaitGroup) {
		defer wgp.Done()
		for i := 0; i < 10; i++ {
				fmt.Println(i)
		}
}

func main() {
		wgp := &sync.WaitGroup{}
		wgp.Add(1)
		go printCount(wgp)
		wgp.Wait()
}
```