Go+Python双语言混合开发第02部分 Go开发学习第11章 go并发编程学习笔记WaitGroup用于等待一

第11章 go并发编程

最后附上下载链接

11.1 go语言的goroutine

11.1.1 go轻松开启100万个协程

package main

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

var wx sync.WaitGroup
func main() {
    for i:=0; i < 1000000; i++ {
        wx.Add(1)
        go func(i int){
            defer wx.Done()
            for {
                fmt.Println(i)
                time.Sleep(time.Second*1)
            }
        }(i)
    }
    wx.Wait()
}

11.1.2 python起送开启100万个协程

import asyncio
import time

async def say_after(index):
    while 1:
        await asyncio.sleep(1)
        print(index)

tasks = []
async def main():
    print(f"started at {time.strftime('%X')}")
    for i in range(1000000):
        tasks.append(asyncio.create_task(say_after(i)))
        # await say_after(2, 'world')

    await asyncio.gather(*tasks)

asyncio.run(main())

11.2 使用waitGroup

WaitGroup用于等待一组线程的结束。父线程调用Add方法来设定应等待的线程的数量。每个被等待的线程在结束时应调用Done方法。同时，主线程里可以调用Wait方法阻塞至所有线程结束。但在使用时，也有一些问题需要注意

通过WaitGroup提供的三个函数：Add,Done,Wait，可以轻松实现等待某个协程或协程组完成的同步操作。但在使用时要注意:

Add的数量和Done的调用数量必须相等。
另外，就是WaitGroup结构一旦定义就不能复制的原因。

WaitGroup在需要等待多个任务结束再返回的业务来说还是很有用的，但现实中用的更多的可能是，先等待一个协程组，若所有协程组都正确完成，则一直等到所有协程组结束；若其中有一个协程发生错误，则告诉协程组的其他协程，全部停止运行（本次任务失败）以免浪费系统资源。

该场景WaitGroup是无法实现的，那么该场景该如何实现呢，就需要用到通知机制，其实也可以用channel来实现，具体的解决办法，请看后续的文章。

这样说来，WaitGroup的使用场景是有限的。

11.3 互斥锁和读写锁

并发会产生的问题 -竞争

并发产生问题的代码

package main

import (
    "fmt"
    "sync"
)

var total int
var wg sync.WaitGroup
func add(){
    defer wg.Done()
    for i := 0; i < 100000; i ++ {
        total += 1
    }
}

func sub(){
    defer wg.Done()
    for i := 0; i < 100000; i ++ {
        total -= 1
    }
}

func main(){
    wg.Add(2)
    go add()
    go sub()
    wg.Wait()
    fmt.Println(fmt.Sprintf("total is: %d", total))
}

通过互斥锁解决并发问题

package main

import (
    "fmt"
    "sync"
)

var total int
var wg sync.WaitGroup
var lock sync.Mutex
func add(){
    defer wg.Done()
    for i := 0; i < 100000; i ++ {
        lock.Lock()
        total += 1
        lock.Unlock()
    }
}

func sub(){
    defer wg.Done()
    for i := 0; i < 100000; i ++ {
        lock.Lock()
        total -= 1
        lock.Unlock()
    }
}

func main(){
    wg.Add(2)
    go add()
    go sub()
    wg.Wait()
    fmt.Println(fmt.Sprintf("total is: %d", total))
}

读写锁

package main

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

var rwLock sync.RWMutex
var wg sync.WaitGroup

func read(){
    defer wg.Done()
    rwLock.RLock()
    fmt.Println("读取数据")
    time.Sleep(time.Second)
    fmt.Println("读取成功")
    rwLock.RUnlock()
}

func write(){
    defer wg.Done()
    rwLock.Lock()
    fmt.Println("修改数据")
    time.Sleep(time.Second*10)
    fmt.Println("修改成功")
    rwLock.Unlock()
}

func main() {
    wg.Add(10)
    for i := 0;i<5;i++ {
        go read()
    }
    for i := 0;i<5;i++ {
        go write()
    }
    wg.Wait()
}

11.4 channel用于goroutine间通信

channel 提供了一种通信机制，通过它，一个 goroutine 可以想另一 goroutine 发送消息。channel 本身还需关联了一个类型，也就是 channel 可以发送数据的类型。例如: 发送 int 类型消息的 channel 写作 chan int 。

说明

1. channel是引用类型，必须初始化
2. 初始化是通过make初始化的
3. 总结：make初始化三种类型:slice, map和channel

1. 申明

var msg chan int

2. 初始化和关闭

msg = make(chan int) #不带缓冲区
msg = make(chan int, 16) #带缓冲区

3. 放数据和取数据

package main

import "fmt"

func main(){
    var msg chan int
    msg = make(chan int, 1)
    msg<- 1
    data := <- msg
    fmt.Println(data)
}

v, ok := <-ch #它可以用来检查Channel是否已经被关闭了。

4. 一个经典错误

package main

import "fmt"

func main(){
    var msg chan int
    msg = make(chan int)
    msg<- 1
    data := <- msg
    fmt.Println(data)
}

5. 通过启动协程消费channel

package main

import (
    "fmt"
    "sync"
)


func main(){
    var msg chan int
    msg = make(chan int)
    go func(){
        data := <- msg
        fmt.Println(data)
    }()
    msg <- 1 #试试把这一行写到11行之后看看
}

6. 通过for range获取channel的数据

range c产生的迭代值为Channel中发送的值，它会一直迭代直到channel被关闭。上面的例子中如果把close(c)注释掉，程序会一直阻塞在for …… range那一行。

func main() {
    go func() {
        time.Sleep(1 * time.Hour)
    }()
    c := make(chan int)
    go func() {
        for i := 0; i < 10; i = i + 1 {
            c <- i
        }
        close(c)
    }()
    for i := range c {
        fmt.Println(i)
    }
    fmt.Println("Finished")
}

7. 关闭

内建的close方法可以用来关闭channel。

总结一下channel关闭后sender的receiver操作。

如果channel c已经被关闭,继续往它发送数据会导致panic: send on closed channel:

import "time"
func main() {
    go func() {
        time.Sleep(time.Hour)
    }()
    c := make(chan int, 10)
    c <- 1
    c <- 2
    close(c)
    c <- 3
}

但是从这个关闭的channel中不但可以读取出已发送的数据，还可以不断的读取零值:

c := make(chan int, 10)
c <- 1
c <- 2
close(c)
fmt.Println(<-c) //1
fmt.Println(<-c) //2
fmt.Println(<-c) //0
fmt.Println(<-c) //0

但是如果通过range读取，channel关闭后for循环会跳出：

c := make(chan int, 10)
c <- 1
c <- 2
close(c)
for i := range c {
    fmt.Println(i)
}

通过i, ok := <-c可以查看Channel的状态，判断值是零值还是正常读取的值。

c := make(chan int, 10)
close(c)
i, ok := <-c
fmt.Printf("%d, %t", i, ok) //0, false

channel可以用在goroutine之间的同步。

下面的例子中main goroutine通过done channel等待worker完成任务。 worker做完任务后只需往channel发送一个数据就可以通知main goroutine任务完成。

import (
    "fmt"
    "time"
)
func worker(done chan bool) {
    time.Sleep(time.Second)
    // 通知任务已完成
    done <- true
}
func main() {
    done := make(chan bool, 1)
    go worker(done)
    // 等待任务完成
    <-done
}

四种通道类型

1. 无缓冲通道
2. 有缓冲通道
3. 单向通道
4. 双向通道

11.5 select

select语句选择一组可能的send操作和receive操作去处理。它类似switch,但是只是用来处理通讯(communication)操作。

它的case可以是send语句，也可以是receive语句，亦或者default。

receive语句可以将值赋值给一个或者两个变量。它必须是一个receive操作。

最多允许有一个default case,它可以放在case列表的任何位置，尽管我们大部分会将它放在最后。

package main

import (
    "fmt"
    "strconv"
    "time"
)

func collector(c chan string, n int){
    for {
        time.Sleep(time.Second*1)
        c <- "imooc"+strconv.Itoa(n)
        //fmt.Println(fmt.Sprintf("%d 获取到了数据"))
    }
}

func main(){
    msg1 := make(chan string)
    msg2 := make(chan string)
    go collector(msg1, 1)
    go collector(msg2, 2)
    //for{
    //  data, ok := <-msg1
    //  if ok {
    //      fmt.Println(data)
    //  }
    //  data, ok = <-msg2
    //  if ok {
    //      fmt.Println(data)
    //  }
    //}
    for{
        select {
        case data1 := <- msg1:
            fmt.Println(data1)
        case data2 := <- msg2:
            fmt.Println(data2)
        }
    }

}

如果有同时多个case去处理,比如同时有多个channel可以接收数据，那么Go会伪随机的选择一个case处理(pseudo-random)。如果没有case需要处理，则会选择default去处理，如果default case存在的情况下。如果没有default case，则select语句会阻塞，直到某个case需要处理。

需要注意的是，nil channel上的操作会一直被阻塞，如果没有default case,只有nil channel的select会一直被阻塞。

select语句和switch语句一样，它不是循环，它只会选择一个case来处理，如果想一直处理channel，你可以在外面加一个无限的for循环：

for {
    select {
    case c <- x:
        x, y = y, x+y
    case <-quit:
        fmt.Println("quit")
        return
    }
}

timeout

select有很重要的一个应用就是超时处理。因为上面我们提到，如果没有case需要处理，select语句就会一直阻塞着。这时候我们可能就需要一个超时操作，用来处理超时的情况。

下面这个例子我们会在2秒后往channel c1中发送一个数据，但是select设置为1秒超时,因此我们会打印出timeout 1,而不是result 1。

import "time"
import "fmt"
func main() {
    c1 := make(chan string, 1)
    go func() {
        time.Sleep(time.Second * 2)
        c1 <- "result 1"
    }()
    select {
    case res := <-c1:
        fmt.Println(res)
    case <-time.After(time.Second * 1):
        fmt.Println("timeout 1")
    }
}

其实它利用的是time.After方法，它返回一个类型为<-chan Time的单向的channel，在指定的时间发送一个当前时间给返回的channel中。

Timer和Ticker

我们看一下关于时间的两个Channel。

timer是一个定时器，代表未来的一个单一事件，你可以告诉timer你要等待多长时间，它提供一个Channel，在将来的那个时间那个Channel提供了一个时间值。下面的例子中第二行会阻塞2秒钟左右的时间，直到时间到了才会继续执行。

timer1 := time.NewTimer(time.Second * 2)
<-timer1.C
fmt.Println("Timer 1 expired")

当然如果你只是想单纯的等待的话，可以使用time.Sleep来实现。

你还可以使用timer.Stop来停止计时器。

timer2 := time.NewTimer(time.Second)
go func() {
    <-timer2.C
    fmt.Println("Timer 2 expired")
}()
stop2 := timer2.Stop()
if stop2 {
    fmt.Println("Timer 2 stopped")
}

ticker是一个定时触发的计时器，它会以一个间隔(interval)往Channel发送一个事件(当前时间)，而Channel的接收者可以以固定的时间间隔从Channel中读取事件。下面的例子中ticker每500毫秒触发一次，你可以观察输出的时间。

ticker := time.NewTicker(time.Millisecond * 500)
go func() {
    for t := range ticker.C {
        fmt.Println("Tick at", t)
    }
}()

类似timer, ticker也可以通过Stop方法来停止。一旦它停止，接收者不再会从channel中接收数据了。

在这里插入图片描述 Go+Python双语言混合开发最后附上视频下载地址官网地址：coding.imooc.com/class/469.h… 百度网盘下载地址：链接: pan.baidu.com/s/1z54qp2yO… 密码: 6dl0 --来自百度网盘超级会员V3的分享

Go+Python双语言混合开发 第02部分 Go开发学习 第11章 go并发编程 学习笔记