定义channel管道
定义一个channel时，也需要定义发送到管道的值类型。channel可以使用内置的make()函数来创建：
|
1
2
|
var ch = make(chan int) //等价于：make(chan Type,0)var ch = make(chan Type,capacity) |
channel管道塞值和取值
|
1
2
3
4
|
ch <- 666 //向ch管道塞入666<- ch // 向ch管道接收值，并丢弃x := <-ch //向ch管道中接收数据，并复制给xx, ok := <-ch //向ch管道中接收数据，并复制给x,同时检查通道是否已关闭或者是否为空 |
当capacity=0时，channel管道是无缓冲阻塞读写，
当capacity>0时，channel管道有缓冲，是非阻塞的，直到写满capacity个元素才阻塞写入。
注意：默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得goroutine同步变得更加简单，而不需要显示的lock。
通过channel管道实现同步，和数据交互
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package mainimport ( "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)} |
无缓冲的channel
ch := make(chan int, 0)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
package mainimport ( "fmt" "time")func main() { //创建一个无缓存的channel 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 < 10000; i++ { fmt.Printf("子协程：i = %d\n", i) ch <- i //往chan写内容 time.Sleep(1 * time.Second) } }() go func() { for { num := <-ch //读管道中内容，没有内容前，阻塞 fmt.Println("num = ", num) } }() for { }} |
有缓冲的channel管道
ch := make(chan int, 3)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package mainimport ( "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) }} |
关闭channel管道
close(ch)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
package mainimport ( "fmt")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 < 10000; i++ { fmt.Printf("子协程：i = %d\n", i) ch <- i //往chan写内容 //time.Sleep(1 * time.Second) if i >10 { close(ch) break } } }() go func() { for { if num, ok := <-ch; ok == true { fmt.Println("num = ", num) } else { //管道关闭 break } } }() for { }} |
单向channel管道,读写分离
chan<- 表示数据进入管道，只写
<-chan 表示数据从管道出来，只读
注意：双向可转为单向，单向不可转为双向
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package main//"fmt"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 ch3 chan int = writeCh //cannot use writeCh (type chan<- int) as type chan int in assignment} |
管道消费者生产者模型
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
package mainimport ( "fmt")//此通道只能写，不能读func producer(out chan<- int) { for i := 0; i < 10; i++ { out <- i * i //写入 } close(out) //关闭}//此channel只能读，不能写func consumer(data <-chan int) { for num := range data { fmt.Println("num = ", num) }}func main() { //创建一个双向通道 ch := make(chan int) //生产者，生产数字，写入channel //新开一个协程 go producer(ch) //channel传参，引用传递 //消费者，从channel读取内容，打印 consumer(ch)} |
以上就是golang channel管道的详细内容，更多关于channel管道的资料请关注服务器之家其它相关文章！
原文链接：https://www.cnblogs.com/guyouyin123/p/13986351.html
