go协程同步的三种方式

1.Mutex   2.channel   3.WaitGroup

 

1.使用锁的方式

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秒
}

2.使用channel通道可以用来作为消息机制也可作为锁机制

　　1.有缓冲/无缓冲channel

无缓冲的channel只能发送完之后协程立马阻塞，只有等有协程接受了之后才能继续发送，

等待协程接受了，之后立马阻塞，等待channel中有数据才会启动

package main

import (
    "fmt"
    "time"
)

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)
}

1//运行结果 
主线程休眠1秒
准备发送1数据
主线程结束休眠
发送1数据完毕
协程开始睡眠1秒
接受 1
协程结束睡眠
发送2数据完毕
接受 

 注意：

func main() {
	c := make(chan int)		//声明一个int类型的无缓冲通道
	c <- 1
	i := <- c
	fmt.Printf("receive %d\n", i)
}会报错
在同一个线程里进行channel读写操作会发生死锁

有缓冲的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)
    }
}

send 0

send 1

receive 0

send 2

receive 1

send 3

receive 2

receive 3

send 4

send 5

receive 4

receive 5

3.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()
}

上面代码输出结果为：

Hello World
Inside my goroutine
Finished Execution

达到了我们想要的结果。

接下来对上面的代码做一些解释：

我们在开启协程之前，先调用了WaitGroup的Add(1)方法，是要设置主函数需要等待完成的协程数为1，Wait()方法是等待协程的完成。我们在协程中调用的WaitGroup的Done()方法，意思是当前协程执行完成（Done()做的工作其实就是把需要等待的协程个数减1），当需要等待的协程数为0时，则不需要再等待，继续执行以下的代码。