26.channel

Abel sun2023年1月6日约 4046 字大约 13 分钟

26.channel

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

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

1，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。

2，通过channel实现同步

package main

import (
 "fmt"
 "time"
)

var ch = make(chan int)

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

func person1() {
 Printer("hello")
 ch <- 666 //给管道写数据
}
func person2() {
 <-ch //从管道取数据，如果通道没有数据，则会一直阻塞
 Printer("world")
}

func main() {
 //新建2个协程，代表2个人，2个人同时使用打印机
 go person1()
 go person2()
 //特地不让主协程结束，创建一个死循环
 for {

 }
}

[success]person1与person2都有可能先执行，因为2在打印之前，添加了一个取数据的管道，而在这个时候管道里边是没有数据的，因此会一直阻塞，继而程序会让1先进行打印，等1打印完成，管道有了数据，2自然也就能够执行打印了。

3，通过channel实现数据同步

package main

import (
 "fmt"
 "time"
)

func main() {
 ch := make(chan string)

 defer fmt.Println("主协程执行完毕！")

 go func() {
  defer fmt.Println("子协程执行完毕")
  for i := 0; i < 3; i++ {
   fmt.Println("子协程 i = ", i)
   time.Sleep(time.Second)
  }

  ch <- "我是子协程！"

 }()

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

此时此刻，略微感受到，语言的魅力与美妙，创建一个chan类型的变量，即可在A当中输出给他，然后其他地方还能够接收，就这样形成了一个管道，有点意思！

4，无缓冲的channel

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

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

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

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

11d62490c0825d22

在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行发送或者接收。
在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个 goroutine 会在通道中被锁住，直到交换完成。
在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住，直到交换完成。
在第 4 步和第 5 步，进行交换，并最终，在第 6 步，两个 goroutine 都将它们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。

无缓冲的channel创建格式：

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

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

示例代码：

package main

import (
 "fmt"
 "time"
)

func main() {
 ch := make(chan int, 0)
 //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.Println("子协程 i = ", i)
   ch <- i //往chan写内容，没有读取之前，阻塞

  }
 }()

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

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

}

代码输出结果：

$ go run 10_无缓存的channel.go
len(ch) = 0, cap(ch) = 0
子协程 i =  0
num =  0
子协程 i =  1
子协程 i =  2
num =  1
num =  2

注意：这个地方可能容易产生疑惑，按理说在第一次子协程输出和主协程输出之后，应该接着输出子协程和主协程的，但是结果却是连着输出了两次子协程，和主协程，大概可以这么理解。第一次子协程输出，然后创建了个管道，因为没有读取，所以阻塞，然后来到主协程，主协程取出管道数据并打印，就在这一刻，子协程的管道释放，然后开始进入for循环打印，一瞬间就完成了两次循环，然后才轮到主协程的打印。

5，有缓冲的channel

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

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

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

示例图如下：

df1abdda3e40649e

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

有缓冲的channel创建格式：

    make(chan Type, capacity)

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

示例代码：

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

}

输出结果：

$ go run 11_有缓存的channel.go
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) = 2, 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

注意：当缓冲区写满的时候，会阻塞，而异步处理的时候，顺序可能随机。

6，close关闭channel

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

package main

import (
 "fmt"
)

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

 go func() {
  for i := 0; i < 5; i++ {
   ch <- i
  }
  //不需要再写数据时，关闭channel
  close(ch)
  //ch <- 666 //关闭后的channel，不能够再写数据
 }()

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

}

程序运行结果：

$ go run 12_关闭channel.go
num =  0
num =  1
num =  2
num =  3
num =  4

注意点：

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

1，使用range进行迭代

当然，上边的主协程输出判断还可以使用如下简便的方式对管道里的数据进行打印。

package main

import (
 "fmt"
)

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

 go func() {
  for i := 0; i < 5; i++ {
   ch <- i
  }
  //不需要再写数据时，关闭channel
  close(ch)
  //ch <- 666 //关闭后的channel，不能够再写数据
 }()

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

}

当管道关闭或者数据取完之后，都会自动跳出循环的。

2，一个示例

创建一个goroutine，生成0-100个数，把这些数放到一个chan中再创建一个goroutine，从上边的chan中取出那些数，然后计算每个数的平方之后再放入到一个新的chan中最后从新的chan中取到数字打印出来

package main

import (
 "fmt"
)

// 创建一个goroutine，生成0-100个数，把这些数放到一个chan中
// 再创建一个goroutine，从上边的chan中取出那些数，然后计算每个数的平方之后再放入到一个新的chan中
// 最后从新的chan中取到数字打印出来

func main() {

 a := make(chan int, 50)
 go func() {
  for i := 0; i < 101; i++ {
   a <- i
  }
  close(a)
 }()
 b := make(chan int, 50)
 go func() {
  for i := range a {
   b <- i * i
  }
  close(b)
 }()

 for v := range b {
  fmt.Println("最总结果为：", v)
 }

}

7，单向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：

示例代码（不需要运行，只需build编译即可检测语法问题）：

package main

func main() {
 //创建一个channel，双向的
 ch := make(chan int)

 //双向channel能够隐式转换为单向channel
 var writeCh chan<- int = ch //只能写不能读
 var readCh <-chan int = ch  //只能读不能写

 writeCh <- 666 //写
 //<-writeCh //err,invalid operation: <-writeCh (receive from send-only type chan<- int)

 <-readCh //读
 //readCh<-666 //err,invalid operation: readCh <- 666 (send to receive-only type <-chan int)

 //注意：单向无法转换为双向
 //var ch2 chan int = writeCh //err,cannot use writeCh (type chan<- int) as type chan int in assignment
}

1，单向channel的应用

package main

import (
 "fmt"
)

func producer(out chan<- int) {
 for i := 0; i < 10; i++ {
  out <- i * i
 }
 close(out)
}

func consumer(in <-chan int) {
 for num := range in {
  fmt.Println("num = ", num)
 }
}

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

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

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

}

8，定时器

1，timer

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

package main

import (
 "fmt"
 "time"
)
//验证time.NewTimer()时间到了之后，只会响应一次
func main() {
 timer := time.NewTimer(1 * time.Second)
 for {
  <-timer.C
  fmt.Println("时间到")
 }
}

func main1() {
 timer := time.NewTimer(2 * time.Second)
 fmt.Println("当前时间是：", time.Now())

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

使用Timer实现延时功能。

package main

import (
 "fmt"
 "time"
)

//延时2s打印一句话
func main1() {
 <-time.After(2 * time.Second) //定时2s,阻塞2s，2s后产生一个时间，往channel中写个内容
 fmt.Println("时间到！")

}

func main2() {
 time.Sleep(2 * time.Second)
 fmt.Println("时间到！")

}

func main() {
 timer := time.NewTimer(2 * time.Second)
 <-timer.C
 fmt.Println("时间到！")
}

停止定时器

package main

import (
 "fmt"
 "time"
)

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

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

 timer.Stop() //停止定时器

 for {

 }
}

此程序什么也不会输出，因为在3秒钟没有结束的时候，定时器就先关闭了，因此不会输出内容。

重置定时器

package main

import (
 "fmt"
 "time"
)

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

 timer.Reset(time.Second)

 <-timer.C
 fmt.Println("时间到")

}

2，Ticker

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

示例代码：

package main

import (
 "fmt"
 "time"
)

func main() {
 ticker := time.NewTicker(time.Second)
 i := 0
 for {
  <-ticker.C
  i++
  fmt.Println("i = ", i)
  if i == 5 {
   ticker.Stop()
   break
  }
 }
}

9，work pool

使用goroutine和channel实现一个计算int64随机数各位数和的程序。
开启一个goroutine循环生成int64类型的随机数，发送到jobChan
开启24个goroutine从jobChan中取出随机数计算各位数的和，将结果发送给resultChan
主goroutine从resultChan中取出结果并在终端打印输出。

package main

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

type job struct {
 value int64
}
type result struct {
 job *job
 sum int64
}

var jobChan = make(chan *job, 100)
var resultChan = make(chan *result, 100)
var wg sync.WaitGroup

func producer(pu chan<- *job) {
 defer wg.Done()
 // 循环生成int64的随机数，发送到jobChan
 for {
  x := rand.Int63()
  newJob := &job{
   value: x,
  }
  pu <- newJob
  time.Sleep(time.Second)
 }
}

func consumer(pu <-chan *job, cm chan<- *result) {
 defer wg.Done()
 // 从jobChan中取出随机数计算各位数的和，将结果发送给resultChan
 for {
  job := <-pu
  sum := int64(0)
  n := job.value
  for n > 0 {
   sum += n % 10
   n = n / 10
  }
  newResult := &result{
   job: job,
   sum: sum,
  }
  resultChan <- newResult
 }

}

func main() {
 wg.Add(1)
 go producer(jobChan)
 //开启24个goroutine执行consumer
 wg.Add(24)
 for i := 0; i < 25; i++ {
  go consumer(jobChan, resultChan)
 }
 // 主goroutine从resultChan中取出结果并打印
 for result := range resultChan {
  fmt.Printf("value:%d sum:%d\n", result.job.value, result.sum)
 }
 wg.Wait()
}

昵称

邮箱

网址

按正序
按倒序
按热度

26.channel

# 26.channel

# 1，channel类型

# 2，通过channel实现同步

# 3，通过channel实现数据同步

# 4，无缓冲的channel

# 5，有缓冲的channel

# 6，close关闭channel

# 1，使用range进行迭代

# 2，一个示例

# 7，单向channel

# 1，单向channel的应用

# 8，定时器

# 1，timer

# 2，Ticker

# 9，work pool

预览:

26.channel

1，channel类型

2，通过channel实现同步

3，通过channel实现数据同步

4，无缓冲的channel

5，有缓冲的channel

6，close关闭channel

1，使用range进行迭代

2，一个示例

7，单向channel

1，单向channel的应用

8，定时器

1，timer

2，Ticker

9，work pool