协程的三种同步方式Channel、Mutex、WaitGroup

1、无缓冲的channel：无缓冲的channel只能发送完之后协程立马阻塞，只有等有协程接受了之后才能继续发送，等待协程接受了，之后立马阻塞，等待channel中有数据才会启动

package main

import (
	"fmt"
	"time"
)

/*
无缓冲的channel只能发送完之后协程立马阻塞，只有等有协程接受了之后才能继续发送，
等待协程接受了，之后立马阻塞，等待channel中有数据才会启动
*/
func main() {
	c := make(chan int) //声明一个int类型的无缓冲通道
	go func() {
		fmt.Println("准备发送1数据")
		c <- 1
		fmt.Println("发送1数据完毕")
		fmt.Println("协程开始睡眠1秒")
		time.Sleep(time.Second)
		fmt.Println("协程结束睡眠")
		c <- 2
		fmt.Println("发送2数据完毕")
	}()

	fmt.Println("主线程休眠1秒")
	time.Sleep(time.Second)
	fmt.Println("主线程结束休眠")
	i := <-c
	fmt.Printf("接受 %d\n", i)
	i = <-c
	fmt.Printf("接受 %d\n", i)
	time.Sleep(time.Second)
}

2、有缓冲的channel：当缓冲区满了发送线程阻塞，缓冲区空了接受线程阻塞

package main

import (
"fmt"
"time"
)
/*
当缓冲区满了发送线程阻塞，缓冲区空了接受线程阻塞
*/

func main() {
	c := make(chan int, 2) //声明一个int类型的有缓冲通道
	go func() {
		for i := 0; i < 4; i++ {
			c <- i
			fmt.Printf("send %d\n", i)
		}
		time.Sleep(5 * time.Second)
		for i := 4; i < 6; i++ {
			c <- i
			fmt.Printf("send %d\n", i)
		}
	}()
	for i := 0; i < 6; i++ {
		time.Sleep(time.Second)
		fmt.Printf("receive %d\n", <-c)
	}
}

3、sync.Mutex

package main

import (
	"fmt"
	"sync"
	"time"
)

var share_cnt uint64 = 0

var lck sync.Mutex

func incrShareCnt() {
	for i := 0; i < 1000000; i++ {
		lck.Lock()
		share_cnt++ //共有资源
		lck.Unlock()
	}
	fmt.Println(share_cnt)
}
func main() {
	for i := 0; i < 2; i++ {
		go incrShareCnt()
	}
	time.Sleep(1 * time.Second) //1秒
}

4、sync.Waitgroup:使用等待组进行多个任务的同步，等待组可以保证在并发环境中完成指定数量的任务

package main

import (
"fmt"
"sync"
)
//使用等待组进行多个任务的同步，等待组可以保证在并发环境中完成指定数量的任务
func main() {
	fmt.Println("Hello World")
	var waitgroup sync.WaitGroup
	waitgroup.Add(1)
	go myFunc(&waitgroup)
	waitgroup.Wait()
	fmt.Println("Finished Execution")
}
func myFunc(waitgroup *sync.WaitGroup) {
	fmt.Println("Inside my goroutine")
	waitgroup.Done()
}