036 go语言并发编程_channel

channel

goroutine运行在相同的地址空间，因此访问共享内存必须做好同步。==goroutine 奉行通过通信来共享内存，而不是共享内存来通信。==

==引⽤类型 channel 是 CSP 模式的具体实现，用于多个 goroutine 通讯。其内部实现了同步，确保并发安全。==

channel类型

和map类似，channel也一个对应make创建的底层数据结构的引用。

当我们复制一个channel或用于函数参数传递时，我们只是拷贝了一个channel引用，因此调用者何被调用者将引用同一个channel对象。和其它的引用类型一样，channel的零值也是nil。

定义一个channel时，也需要定义发送到channel的值的类型。channel可以使用内置的make()函数来创建：

    make(chan Type) //等价于make(chan Type, 0)
    make(chan Type, capacity)

当 capacity= 0 时，channel 是无缓冲阻塞读写的，当capacity> 0 时，channel 有缓冲、是非阻塞的，直到写满 capacity个元素才阻塞写入。

channel通过操作符<-来接收和发送数据，发送和接收数据语法：

    channel <- value      //发送value到channel
    <-channel             //接收并将其丢弃
    x := <-channel        //从channel中接收数据，并赋值给x
    x, ok := <-channel    //功能同上，同时检查通道是否已关闭或者是否为空

默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得goroutine同步变的更加的简单，而不需要显式的lock。

示例代码1：

通过channel实现数据同步与交互

package main

import (
    "fmt"
    "time"
)

func main() {

    //创建channel
    ch := make(chan string)

    defer fmt.Println("主协程也结束")

    go func() {
        defer fmt.Println("子协程调用完毕")

        for i := 0; i < 2; i++ {
            fmt.Println("子协程 i = ", i)
            time.Sleep(time.Second)
        }

        ch <- "我是子协程，要工作完毕"

    }()

    str := <-ch //没有数据前，阻塞
    fmt.Println("str = ", str)
}

程序运行结果：

子协程 i =  0
子协程 i =  1
子协程调用完毕
str =  我是子协程，要工作完毕
主协程也结束

Process finished with exit code 0

示例代码2

package main

import (
    "fmt"
    "time"
)

//全局变量，创建一个channel
var ch = make(chan int)

//定义一个打印机，参数为字符串，按每个字符打印
//打印机属于公共资源
func Printer(str string) {
    for _, data := range str {
        fmt.Printf("%c", data)
        time.Sleep(time.Second)
    }
    fmt.Printf("\n")
}

//person1执行完后，才能到person2执行
func person1() {
    Printer("hello")
    ch <- 666 //给管道写数据，发送
}

func person2() {
    <-ch //从管道取数据，接收，如果通道没有数据他就会阻塞,这样就会顺序的执行
    Printer("world")
}

func main() {
    //新建2个协程，代表2个人，2个人同时使用打印机
    go person1()
    go person2()

    //特地不让主协程结束，死循环
    for {

    }
}

执行结果

hello
world

image-20200117171644015.png

无缓冲的channel

无缓冲的通道（unbuffered channel）是指在 ==接收前没有能力保存任何值的通道。==

这种类型的通道要求发送 goroutine 和接收 goroutine 同时准备好，才能完成发送和接收操作。如果两个goroutine没有同时准备好，通道会导致先执行发送或接收操作的 goroutine 阻塞等待。

这种对通道进行发送和接收的交互行为本身就是同步的。其中任意一个操作都无法离开另一个操作单独存在。

下图展示两个 goroutine 如何利用无缓冲的通道来共享一个值：

clip_image004.png

• 在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行发送或者接收。

• 在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个 goroutine 会在通道中被锁住，直到交换完成。

• 在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住，直到交换完成。

• 在第 4 步和第 5 步，进行交换，并最终，在第 6 步，两个 goroutine 都将它们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。

无缓冲的channel创建格式：

    make(chan Type) //等价于make(chan Type, 0)//不指定容量

如果没有指定缓冲区容量，那么该通道就是同步的，因此会阻塞到发送者准备好发送和接收者准备好接收。

示例代码1：

func main() {
    c := make(chan int, 0) //无缓冲的通道
 
    //内置函数 len 返回未被读取的缓冲元素数量， cap 返回缓冲区大小
    fmt.Printf("len(c)=%d, cap(c)=%d\n", len(c), cap(c))
 
    go func() {
        defer fmt.Println("子协程结束")
 
        for i := 0; i < 3; i++ {
            c <- i
            fmt.Printf("子协程正在运行[%d]: len(c)=%d, cap(c)=%d\n", i, len(c), cap(c))
        }
    }()
 
    time.Sleep(2 * time.Second) //延时2s
 
    for i := 0; i < 3; i++ {
        num := <-c //从c中接收数据，并赋值给num
        fmt.Println("num = ", num)
    }
 
    fmt.Println("main协程结束")
}

程序运行结果：

clip_image006.jpg

示例代码2:

package main

import (
    "fmt"
    "time"
)

func main() {
    //创建一个无缓冲的channel
    ch := make(chan int, 0)  //指定的容量为0,是无缓冲的channel

    //len(ch)缓冲区剩余数据个数， cap(ch)缓冲区大小
    fmt.Printf("len(ch) = %d, cap(ch)= %d\n", len(ch), cap(ch))

    //新建协程
    go func() {
        for i := 0; i < 3; i++ {
            fmt.Printf("子协程：i = %d\n", i)
            ch <- i //往chan写内容
        }
    }()   //加括号表示执行

    //延时
    time.Sleep(2 * time.Second)  //延时两秒

    for i := 0; i < 3; i++ {
        num := <-ch //读管道中内容，没有内容前，阻塞
        fmt.Println("num = ", num)
    }

}

执行结果

len(ch) = 0, cap(ch)= 0
子协程：i = 0
num =  0
子协程：i = 1
子协程：i = 2
num =  1  //读完数据还没来得及打印,先打印了上面那个
num =  2

有缓冲的channel

有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个值的通道。

这种类型的通道 ==并不强制要求 goroutine 之间必须同时完成发送和接收。== 通道会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。

这导致有缓冲的通道和无缓冲的通道之间的一个很大的不同：无缓冲的通道保证进行发送和接收的 goroutine 会在同一时间进行数据交换；有缓冲的通道没有这种保证。

示例图如下：

clip_image008.png

• 在第 1 步，右侧的 goroutine 正在从通道接收一个值。
• 在第 2 步，右侧的这个 goroutine独立完成了接收值的动作，而左侧的 goroutine 正在发送一个新值到通道里。
• 在第 3 步，左侧的goroutine 还在向通道发送新值，而右侧的 goroutine 正在从通道接收另外一个值。这个步骤里的两个操作既不是同步的，也不会互相阻塞。
• 最后，在第 4 步，所有的发送和接收都完成，而通道里还有几个值，也有一些空间可以存更多的值。

有缓冲的channel创建格式：

    make(chan Type, capacity)

如果给定了一个缓冲区容量，通道就是异步的。只要缓冲区有未使用空间用于发送数据，或还包含可以接收的数据，那么其通信就会无阻塞地进行。

示例代码1：

func main() {
    c := make(chan int, 3) //带缓冲的通道(缓冲区大小为3)
 
    //内置函数 len 返回未被读取的缓冲元素数量， cap 返回缓冲区大小
    fmt.Printf("len(c)=%d, cap(c)=%d\n", len(c), cap(c))
 
    go func() {
        defer fmt.Println("子协程结束")
 
        for i := 0; i < 3; i++ {
            c <- i  //在缓冲区未满前一直发送数据
            fmt.Printf("子协程正在运行[%d]: len(c)=%d, cap(c)=%d\n", i, len(c), cap(c))
        }
    }()
 
    time.Sleep(2 * time.Second) //延时2s
    for i := 0; i < 3; i++ {
        num := <-c //从c中接收数据，并赋值给num
        fmt.Println("num = ", num)
    }
    fmt.Println("main协程结束")
}

程序运行结果：

clip_image010.jpg

示例代码2

package main

import (
    "fmt"
    "time"
)

func main() {
    //创建一个有缓存的channel
    ch := make(chan int, 3)

    //len(ch)缓冲区剩余数据个数， cap(ch)缓冲区大小
    fmt.Printf("len(ch) = %d, cap(ch)= %d\n", len(ch), cap(ch))

    //新建协程
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i //往chan写内容   这里需要写的比缓冲区的容量要大
            fmt.Printf("子协程[%d]: len(ch) = %d, cap(ch)= %d\n", i, len(ch), cap(ch))
        }
    }()

    //延时
    time.Sleep(2 * time.Second)

    for i := 0; i < 10; i++ {
        num := <-ch //读管道中内容，没有内容前，阻塞
        fmt.Println("num = ", num)
    }

}

执行结果:

len(ch) = 0, cap(ch)= 3
子协程[0]: len(ch) = 1, cap(ch)= 3
子协程[1]: len(ch) = 2, cap(ch)= 3
子协程[2]: len(ch) = 3, cap(ch)= 3   //这里会出现阻塞的现象(注意时间延时)
num =  0
num =  1
num =  2
num =  3
子协程[3]: len(ch) = 0, cap(ch)= 3
子协程[4]: len(ch) = 0, cap(ch)= 3
子协程[5]: len(ch) = 1, cap(ch)= 3
子协程[6]: len(ch) = 2, cap(ch)= 3
子协程[7]: len(ch) = 3, cap(ch)= 3
num =  4
num =  5
num =  6
num =  7
num =  8
子协程[8]: len(ch) = 0, cap(ch)= 3
子协程[9]: len(ch) = 0, cap(ch)= 3
num =  9

Process finished with exit code 0

range和close

如果发送者知道，没有更多的值需要发送到channel的话，那么让接收者也能及时知道没有多余的值可接收将是有用的，因为接收者可以停止不必要的接收等待。==这可以通过内置的close函数来关闭channel实现。==

示例代码1：

func main() {
    c := make(chan int)
 
    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        //把 close(c) 注释掉，程序会一直阻塞在 if data, ok := <-c; ok 那一行
        close(c)
    }()
 
    for {
        //ok为true说明channel没有关闭，为false说明管道已经关闭
        if data, ok := <-c; ok {  //先给ok赋值然后判断ok的值
            fmt.Println(data)
        } else {
            break
        }
    }
 
    fmt.Println("Finished")
}

程序运行结果：

clip_image012.jpg

注意点：

• channel不像文件一样需要经常去关闭，只有当你确实没有任何发送数据了，或者你想显式的结束range循环之类的，才去关闭channel；
• 关闭channel后，无法向channel 再发送数据(引发 panic 错误后导致接收立即返回零值)；
• 关闭channel后，可以继续向channel接收数据；
• 对于nil channel，无论收发都会被阻塞。

可以使用 range 来迭代不断操作channel：

func main() {
    c := make(chan int)
 
    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        //把 close(c) 注释掉，程序会一直阻塞在 for data := range c 那一行
        close(c)
    }()
 
    for data := range c {
        fmt.Println(data)
    }
    fmt.Println("Finished")
}

代码示例2

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int) //创建一个无缓存channel

    //新建一个goroutine
    go func() {
        for i := 0; i < 5; i++ {
            ch <- i //往通道写数据
        }
        //不需要再写数据时，关闭channel
        close(ch)
        //ch <- 666 //关闭channel后无法再发送数据

    }() //别忘了()

    for num := range ch {
        fmt.Println("num = ", num)
    }

}

func main01() {
    ch := make(chan int) //创建一个无缓存channel

    //新建一个goroutine
    go func() {
        for i := 0; i < 5; i++ {
            ch <- i //往通道写数据
        }
        //不需要再写数据时，关闭channel
        close(ch)
        //ch <- 666 //关闭channel后无法再发送数据

    }() //别忘了()

    for {
        //如果ok为true，说明管道没有关闭
        if num, ok := <-ch; ok == true {
            fmt.Println("num = ", num)
        } else { //管道关闭
            break
        }
    }

}

执行结果

num =  0
num =  1
num =  2
num =  3
num =  4

单方向的channel

默认情况下，通道是双向的，也就是，既可以往里面发送数据也可以同里面接收数据。

但是，我们经常见一个通道作为参数进行传递而值希望对方是单向使用的，==要么只让它发送数据，要么只让它接收数据，这时候我们可以指定通道的方向。==

单向channel变量的声明非常简单，如下：

var ch1 chan int       // ch1是一个正常的channel，不是单向的
var ch2 chan<- float64 // ch2是单向channel，只用于写float64数据
var ch3 <-chan int     // ch3是单向channel，只用于读取int数据

• chan<- 表示数据进入管道，要把数据写进管道，对于调用者就是输出。

• <-chan 表示数据从管道出来，对于调用者就是得到管道的数据，当然就是输入。

可以将 channel 隐式转换为单向队列，只收或只发，不能将单向 channel 转换为普通 channel：

    c := make(chan int, 3)
    var send chan<- int = c // send-only
    var recv <-chan int = c // receive-only
    send <- 1
    //<-send //invalid operation: <-send (receive from send-only type chan<- int)
    <-recv
    //recv <- 2 //invalid operation: recv <- 2 (send to receive-only type <-chan int)
 
    //不能将单向 channel 转换为普通 channel
    d1 := (chan int)(send) //cannot convert send (type chan<- int) to type chan int
    d2 := (chan int)(recv) //cannot convert recv (type <-chan int) to type chan int

示例代码：

//   chan<- //只写
func counter(out chan<- int) {
    defer close(out)  //最后关闭管道
    for i := 0; i < 5; i++ {
        out <- i //如果对方不读 会阻塞
    }
}
 
//   <-chan //只读
func printer(in <-chan int) {
    for num := range in {
        fmt.Println(num)
    }
}
 
func main() {
    c := make(chan int) //   chan   //读写
 
    go counter(c) //生产者
    printer(c)    //消费者
 
    fmt.Println("done")
}

示例代码

package main

import (
    "fmt"
)

//此通道只能写，不能读
func producer(out chan<- int) {
    for i := 0; i < 10; i++ {
        out <- i * i
    }
    close(out)
}

//此channel只能读，不能写
func consumer(in <-chan int) {
    for num := range in {
        fmt.Println("num = ", num)
    }
}

func main() {
    //创建一个双向通道
    ch := make(chan int)

    //生产者，生产数字，写入channel
    //新开一个协程
    go producer(ch) //channel传参，引用传递

    //消费者，从channel读取内容，打印
    consumer(ch)
}

执行结果

num =  0
num =  1
num =  4
num =  9
num =  16
num =  25
num =  36
num =  49
num =  64
num =  81

Process finished with exit code 0

定时器

Timer(time模块)

==Timer是一个定时器，代表未来的一个单一事件，你可以告诉timer你要等待多长时间，它提供一个channel，在将来的那个时间那个channel提供了一个时间值。==

示例代码1: Timer的使用

func main() {
    //创建一个定时器，设置时间为2s，2s后，往time通道写内容（当前时间）
    timer := time.NewTimer(2 * time.Second)
    fmt.Println("当前时间：", time.Now())

    //2s后，往timer.C写数据，有数据后，就可以读取
    t := <-timer.C //channel没有数据前后阻塞
    fmt.Println("t = ", t)
}

执行结果

录制_2020_01_19_09_51_19_418.gif

package main

import (
    "fmt"
    "time"
)

//验证time.NewTimer()，时间到了，只会响应一次
func main() {
    timer := time.NewTimer(1 * time.Second)

    for {  //相当于其它语言的while循环
        <-timer.C //只会输出一次数据
        fmt.Println("时间到")
    }
}

执行结果

时间到   //只会响应一次
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
    E:/Day6/第06天(并发编程)/4-源代码/15_Timer的使用.go:13 +0x47

示例代码2:通过Timer实现延时功能

func main() {
    time1 := time.Now()
    //延时2s后打印一句话
    timer := time.NewTimer(2 * time.Second)   //使用Timer实现延时
    <-timer.C
    fmt.Println("时间到")
    fmt.Printf("时间差为: %v",time.Now().Sub(time1))

执行结果

时间到
时间差为: 2.0003546s

func main() {
    time.Sleep(2 * time.Second)   //使用Sleep实现延时
    fmt.Println("时间到")
}

执行结果

时间到

package main

import (
    "fmt"
    "time"
)

func main() {
    time1 := time.Now()
    //使用 After实现延时
    <-time.After(2 * time.Second) //定时2s， 阻塞2s, 2s后产生一个事件，往channel写内容
    fmt.Println("时间到")
    fmt.Println(time.Now().Sub(time1))   //前后的相差时间
}

执行结果:

时间到
2.0003811s

定时器停止

不使用定时器停止

func main() {
    timer := time.NewTimer(3 * time.Second)   //3秒的timer

    go func() {
        <-timer.C
        fmt.Println("子协程可以打印了，因为定时器的时间到")
    }()

    //timer.Stop() //停止定时器  ,使用的是Stop函数

    for {

    }
}

执行结果

录制_2020_01_19_10_24_47_934.gif

使用定时器进行停止

func main() {
    timer := time.NewTimer(3 * time.Second)   //3秒的timer

    go func() {
        <-timer.C
        fmt.Println("子协程可以打印了，因为定时器的时间到")
    }()

    timer.Stop() //停止定时器  ,使用的是Stop函数

    for {

    }
}

执行结果

因为被停止了定时器,子协程一直被阻塞不能进行打印的操作

录制_2020_01_19_10_27_03_926.gif

定时器重置

package main

import (
    "fmt"
    "time"
)

func main() {
    time1 := time.Now()
    timer := time.NewTimer(3 * time.Second)
    ok := timer.Reset(1 * time.Second) //重新设置为1s//使用Reset函数
    fmt.Println("ok = ", ok)

    <-timer.C
    fmt.Println("时间到")
    fmt.Println("时间差: ",time.Now().Sub(time1))
}

执行结果

ok =  true
时间到
时间差:  1.0000534s

示例代码：

import "fmt"
import "time"
 
func main() {
    //创建定时器，2秒后，定时器就会向自己的C字节发送一个time.Time类型的元素值
    timer1 := time.NewTimer(time.Second * 2)
    t1 := time.Now() //当前时间
    fmt.Printf("t1: %v\n", t1)
 
    t2 := <-timer1.C  //取出c字节中的元素值,没有数据的话会阻塞在这
    fmt.Printf("t2: %v\n", t2)
 
    //如果只是想单纯的等待的话，可以使用 time.Sleep 来实现
    timer2 := time.NewTimer(time.Second * 2)
    <-timer2.C
    fmt.Println("2s后")
 
    time.Sleep(time.Second * 2) //延时两秒
    fmt.Println("再一次2s后")
 
    <-time.After(time.Second * 2)
    fmt.Println("再再一次2s后")
 
    timer3 := time.NewTimer(time.Second)
    go func() {
        <-timer3.C
        fmt.Println("Timer 3 expired")
    }()
 
    stop := timer3.Stop() //停止定时器
    if stop {
        fmt.Println("Timer 3 stopped")
    }
 
    fmt.Println("before")
    timer4 := time.NewTimer(time.Second * 5) //原来设置3s
    timer4.Reset(time.Second * 1)            //重新设置时间
    <-timer4.C
    fmt.Println("after")
}

Ticker

==Ticker是一个定时触发的计时器，它会以一个间隔(interval)往channel发送一个事件(当前时间)，而channel的接收者可以以固定的时间间隔从channel中读取事件。==

示例代码：

package main

import (
    "fmt"
    "time"
)

func main() {
    //创建定时器，每隔1秒后，定时器就会给channel发送一个事件(当前时间)
    ticker := time.NewTicker(time.Second * 1)

    i := 0
    go func() {
        for { //循环
            time1 := time.Now()
            <-ticker.C
            i++
            fmt.Println("i = ", i)
            fmt.Println("时间差",time.Now().Sub(time1))

            if i == 5 {
                ticker.Stop() //停止定时器
            }
        }
    }() //别忘了()

    //死循环，特地不让main goroutine结束
    for {
    }
}

执行结果

i =  1
时间差 1.0166716s
i =  2
时间差 982.6834ms
i =  3
时间差 999.6767ms
i =  4
时间差 1.0016779s
i =  5
时间差 998.6787ms

Process finished with exit code 2

select

select作用

==Go里面提供了一个关键字select，通过select可以监听channel上的数据流动。==

select的用法与 switch语言 非常类似，由select开始一个新的选择块，每个选择条件由case语句来描述。

与switch语句可以选择任何可使用相等比较的条件相比， ==select有比较多的限制，其中最大的一条限制就是每个case语句里必须是一个IO操作，大致的结构如下：==

    select {
    case <-chan1:
        // 如果chan1成功读到数据，则进行该case处理语句
    case chan2 <- 1:
        // 如果成功向chan2写入数据，则进行该case处理语句
    default:
        // 如果上面都没有成功，则进入default处理流程
    }

在一个select语句中，Go语言会按顺序从头至尾评估每一个发送和接收的语句。

==如果其中的任意一语句可以继续执行(即没有被阻塞)，那么就从那些可以执行的语句中任意选择一条来使用。==

如果没有任意一条语句可以执行(即所有的通道都被阻塞)，那么有两种可能的情况：

• 如果给出了default语句，那么就会执行default语句，同时程序的执行会从select语句后的语句中恢复。

• 如果没有default语句，那么select语句将被阻塞，直到至少有一个通信可以进行下去。

示例代码：使用select实现斐波那契数列

利用select与两个channel的配合实现了斐波那契数列的求解

//fibonacci     1 1 2 3 5 8

package main

import (
    "fmt"
)

//ch只写，quit只读
func fibonacci(ch chan<- int, quit <-chan bool) {
    x, y := 1, 1
    for {
        //监听channel数据的流动
        select {
        case ch <- x:
            x, y = y, x+y
        case flag := <-quit:
            fmt.Println("flag = ", flag)
            return
        }
    }
}

func main() {
    ch := make(chan int)    //数字通信
    quit := make(chan bool) //程序是否结束

    //消费者，从channel读取内容
    //新建协程
    go func() {
        for i := 0; i < 8; i++ {
            num := <-ch //从ch 通道中读取,并打印
            fmt.Println(num)
        }
        //可以停止
        quit <- true  //循环完成后停止
    }() //别忘了()

    //生产者，产生数字，写入channel
    fibonacci(ch, quit)

}

运行结果如下：

1
1
2
3
5
8
13
21
flag =  true

Process finished with exit code 0

超时

==有时候会出现goroutine阻塞的情况，那么我们如何避免整个程序进入阻塞的情况呢？我们可以利用select来设置超时，通过如下的方式实现：==

package main

import "fmt"
import "time"

func main() {
    c := make(chan int)
    o := make(chan bool)
    go func() {
        for {
            select {
            case v := <-c:
                fmt.Println(v)
            case <-time.After(5 * time.Second):
                fmt.Println("timeout")
                o <- true
                break  //时间超时后直接结束了这个循环
            }
        }
    }()
    c <- 666 // 注释掉，直接引发 timeout
    <-o
}

执行

666
timeout

代码示例

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int)
    quit := make(chan bool)

    //新开一个协程
    go func() {
        for {
            select {
            case num := <-ch:
                fmt.Println("num = ", num)
            case <-time.After(3 * time.Second):   //本来是阻塞在select这里,但是 这里3s后就停止了阻塞
                fmt.Println("超时")
                quit <- true
            }
        }

    }() //别忘了()

    for i := 0; i < 5; i++ {
        ch <- i  //通道里存数据
        time.Sleep(time.Second)
    }

    <-quit
    fmt.Println("程序结束")

}

执行结果

num =  0
num =  1
num =  2
num =  3
num =  4
超时
程序结束