1.1 背景

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan string)
    go sendData(ch)
    go getData(ch)
    time.Sleep(100 * time.Second)
}
func sendData(ch chan string) {
    ch <- "Washington"
    ch <- "Tripoli"
    ch <- "London"
    ch <- "Beijing"
    ch <- "Tokio"
}
func getData(ch chan string) {
    var input string
    for {
        input = <-ch
        fmt.Println(input)
    }
}

会有一个问题，如果sleep时间都结束了，但是sendData和getdata所在的函数还没执行完，那么也会被中断执行，如何解决呢：

解决办法：

1、死循环：( 缺点：有时生产者和消费者已经执行完，却依然还在死循环，退不出。)

2、标识位，也就是全局变量和加锁（缺点：比较麻烦，如果有100个goroutine，也要写100个标识位）

上述2个办法都太麻烦不可取，可以pass掉了，下面我们有更好办法：

如何等待一组goroutine结束？

有下面2中方法，GO语言提供了2种方法Channel和WaitGroup来解决goroutine同步和通讯，我们还是比较推荐第二种WaitGroup

补充：

https://studygolang.com/articles/9173

1.2 方法一，使用不带缓冲区的channel实现

带缓冲区也是可以的

实例如下：

package main

import (
    "fmt"
    "time"
)

func process(i int, ch chan bool) {
    fmt.Println("started Goroutine ", i)
    time.Sleep(2 * time.Second)
    fmt.Printf("Goroutine %d ended\n", i)
    ch <- true
}
func main() {
    no := 3
    exitChan := make(chan bool, no)
    for i := 0; i < no; i++ {
        go process(i, exitChan)
    }
    for i := 0; i < no; i++ {
        <-exitChan
    }
    fmt.Println("All go routines finished executing")
}

执行结果如下：

1.3 方法二，使用sync.WaitGroup实现

package main

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

func process(i int, wg *sync.WaitGroup) {
    fmt.Println("started Goroutine ", i)
    time.Sleep(2 * time.Second)
    fmt.Printf("Goroutine %d ended\n", i)
    wg.Done()
}
func main() {
    no := 3
    var wg sync.WaitGroup
    for i := 0; i < no; i++ {
        wg.Add(1)
        go process(i, &wg)
    }
    wg.Wait()
    fmt.Println("All go routines finished executing")
}

执行结果如下：

1.4 补充实例

1.4.1 方法1：channel

代码实例：

package main

import (
    "fmt"
    //  "time"
)

func main() {
    ch := make(chan string)
    exitChan := make(chan bool, 3) //此例我们有3个goroutine，所以我们定义一个长度为3的channel，当我的channel中可以读取到3个元素时，即表示3个goroutine都执行完毕了。
    go sendData(ch, exitChan) //每一个goroutine执行结束时，往channel中插入一个数据
    go getData(ch, exitChan)
    go getData2(ch, exitChan)

    //等待其他goroutine退出，当goroutine都执行完毕退出之后，channel中有3个元素，我们可以做一个取3次的操作，当3次都取完了，表示所有goroutine都退出了
    <-exitChan  //从channel中取出来元素并未赋值给任何变量，就相当于丢弃了
    <-exitChan
    <-exitChan
    fmt.Printf("main goroutine exited\n")
}

func sendData(ch chan string, exitCh chan bool) {
    ch <- "aaa"
    ch <- "bbb"
    ch <- "ccc"
    ch <- "ddd"
    ch <- "eee"
    close(ch) //插入数据结束后，关闭管道channnel
    fmt.Printf("send data exited")
    exitCh <- true //此时已经往goroutine中插入数据结束，goroutine退出之前，往我们定义的channel中插入一个数据true，相当于告知我已经执行完成
}

func getData(ch chan string, exitCh chan bool) {
    //var input string
    for {
        //input = <- ch
        input, ok := <-ch  //检查管道是否被关闭
        if !ok {  //如果被关闭了，ok=false，我们就break退出
            break
        }
        // 此处 打印出来的顺序 和写入的顺序 是一致的
        // 遵循队列的原则: 先入先出
        fmt.Printf("getData中的input值:%s\n", input)
    }
    fmt.Printf("get data exited\n")
    exitCh <- true
}

func getData2(ch chan string, exitCh chan bool) {
    //var input2 string
    for {
        //input2 = <- ch
        input2, ok := <-ch
        if !ok {
            break
        }
        // 此处 打印出来的顺序 和写入的顺序 是一致的
        // 遵循队列的原则: 先入先出
        fmt.Printf("getData2中的input值:%s\n", input2)
    }
    fmt.Printf("get data2 exited\n")
    exitCh <- true
}

执行结果如下：

注意：当我们为channel中放入10个元素，然后把channel关闭，这些元素还是在channel中的，不会消失的，之后想取还是可以取出来的。

1.4.2 方法2：Waitgroup（推荐）

针对大批量goroutine，用sync包中的waitGroup方法，其本身是一个结构体，该方法的本质在底层就是一个计数。

代码实例如下：

package main

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

func main() {
    var wg sync.WaitGroup //定义一个waitgroup（结构体）类型的变量，针对大批量goroutine时比较方便。
    ch := make(chan string)
    wg.Add(3) //3个goroutine，就传入3，Add方法相当于计数
    go sendData(ch, &wg) //，相当于goroutine执行完，Add计数就减1，所以我们将wg传入，但注意结构体必须要传入一个地址进去
    go getData(ch, &wg)
    go getData2(ch, &wg)

    wg.Wait() //只要Add中计数依然存在，就一直Wait，除非为0
    fmt.Printf("main goroutine exited\n")
}

func sendData(ch chan string, waitGroup *sync.WaitGroup) {
    ch <- "aaa"
    ch <- "bbb"
    ch <- "ccc"
    ch <- "ddd"
    ch <- "eee"
    close(ch)
    fmt.Printf("send data exited")
    waitGroup.Done()  //goroutine退出时，计数减1，所以这里用Done方法来通知Add方法
}

func getData(ch chan string, waitGroup *sync.WaitGroup) {
    //var input string
    for {
        //input = <- ch
        input, ok := <-ch
        if !ok {
            break
        }
        // 此处 打印出来的顺序 和写入的顺序 是一致的
        // 遵循队列的原则: 先入先出
        fmt.Printf("getData中的input值:%s\n", input)
    }
    fmt.Printf("get data exited\n")
    waitGroup.Done()
}

func getData2(ch chan string, waitGroup *sync.WaitGroup) {
    //var input2 string
    for {
        //input2 = <- ch
        input2, ok := <-ch
        if !ok {
            break
        }
        // 此处 打印出来的顺序 和写入的顺序 是一致的
        // 遵循队列的原则: 先入先出
        fmt.Printf("getData2中的input值:%s\n", input2)
    }
    fmt.Printf("get data2 exited\n")
    waitGroup.Done()
}

执行结果如下：

二、原子操作

主要还是为了解决线程安全的问题。

2.1 介绍

A. 加锁代价比较耗时，需要上下文切换

B. 针对基本数据类型，可以使用原子操作保证线程安全

C. 原子操作在用户态就可以完成，因此性能比互斥锁要高

D．针对特定需求，原子操作一步就可以操作完成，而加锁就需要好几步（加锁-操作-解锁）

2.2 适用范围

原子操作适用于一些简单操作的数据类型，对于复杂数据类型还是需要借助锁。

2.3 实例

有计数的需求，可以采用原子操作；

package main

import (
    "fmt"
    "sync/atomic" //原子操作需要借助aync中的atomic包
    "time"
)

var count int32

//var mutex sync.Mutex

func test1() {
    for i := 0; i < 1000000; i++ {
        /*  注释掉的这部分是如果采用加锁操作写法
        mutex.Lock()  
        count++
        mutex.Unlock()
        */
        atomic.AddInt32(&count, 1)  //AddInt32函数的第一个参数是传入要修改的变量的地址，第二个参数是要加多少，这样我们就可以借助原子进行操作，而不是加锁了。
    }
}

func test2() {
    for i := 0; i < 1000000; i++ {
        /* 注释掉的这部分是如果采用加锁操作写法
        mutex.Lock()
        count++
        mutex.Unlock()
        */
        atomic.AddInt32(&count, 1)
    }
}

func main() {
    go test1()
    go test2()

    time.Sleep(time.Second)
    fmt.Printf("count=%d\n", count)
}