golang channel管道
Jeff的技术栈 人气:0定义channel管道
定义一个channel时，也需要定义发送到管道的值类型。channel可以使用内置的make()函数来创建：
var ch = make(chan int) //等价于：make(chan Type,0) var ch = make(chan Type,capacity)
channel管道塞值和取值
ch <- 666 //向ch管道塞入666 <- ch // 向ch管道接收值，并丢弃 x := <-ch //向ch管道中接收数据，并复制给x x, ok := <-ch //向ch管道中接收数据，并复制给x,同时检查通道是否已关闭或者是否为空
当capacity=0时，channel管道是无缓冲阻塞读写，
当capacity>0时，channel管道有缓冲，是非阻塞的，直到写满capacity个元素才阻塞写入。
注意：默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得goroutine同步变得更加简单，而不需要显示的lock。
通过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)
}
无缓冲的channel
ch := make(chan int, 0)
package main
import (
"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)
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)
}
}
关闭channel管道
close(ch)
package main
import (
"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 表示数据从管道出来，只读
注意：双向可转为单向，单向不可转为双向
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
}
管道消费者生产者模型
package main
import (
"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)
}
加载全部内容