go中的chan管道机制

前言

在 Go 语言中，提倡通过通信来共享内存，而不是通过共享内存来通信，go中的Channel(一般简写为 chan) 管道提供了一种机制，它在两个并发执行的协程之间进行同步，并通过传递与该管道元素类型相符的值来进行通信，可以用来两个不同的协程之间共享数据

chan使用

chan类型

channel是一种类型，一种引用类型,声明类型时，可以使用

go

代码解读

复制代码

var chan2 = make(chan int)

或者

go

代码解读

复制代码

var chan2 = make(chan int64)

等等，创建chan用make实现，并且channel遵循先进先出原则

chan使用

chan在两个不同的协程之间通讯

go

代码解读

复制代码

package main import ( "fmt" _ "fmt" "time" ) func main() { var chan2 = make(chan int) go say(chan2) go say1(chan2) time.Sleep(5 * time.Second) } func say(a chan<- int) { for i := 0; i < 100; i++ { a <- i } } func say1(a <-chan int) { for i := 0; i < 100; i++ { data := <-a fmt.Println(data) } }

chan使用注意

chan分为无缓存 channel 和有缓存 channel，例如

有缓存 channel

go

代码解读

复制代码

package main import ( _ "fmt" "log" ) func main() { var chan2 = make(chan int) chan2 <- 1 data := <-chan2 log.Println("data的值为:", data) }

以上输出结果为

是因为无缓存线写之后，会阻塞

有缓存channel

go

代码解读

复制代码

package main import ( _ "fmt" "log" ) func main() { var chan2 = make(chan int, 1) chan2 <- 1 data := <-chan2 log.Println("data的值为:", data) }

以上输出结果为

但是超过定义的缓存，就会发生死锁

go

代码解读

复制代码

package main import ( _ "fmt" "log" ) func main() { var chan2 = make(chan int, 1) chan2 <- 1 chan2 <- 2 data := <-chan2 log.Println("data的值为:", data) }

以上输出结果为

从chan取值

使用range可以从channel取值。如

go

代码解读

复制代码

package main import "log" func main() { ch := make(chan int64) go say(ch) for i := range ch { data := i log.Println(data) } } func say(ch chan int64) { for i := 0; i < 100; i++ { ch <- int64(i) } close(ch) }

以上结果为

但是要注意的是，在使用range遍历时，需要关闭管道，否则会报死锁

go

代码解读

复制代码

package main import "log" func main() { ch := make(chan int64) go say(ch) for i := range ch { data := i log.Println(data) } } func say(ch chan int64) { for i := 0; i < 100; i++ { ch <- int64(i) } //close(ch) }

以上输出结果为

channel只读没写，也会报死锁问题

go

代码解读

复制代码

package main import "fmt" func main() { ch := make(chan int64) data := <-ch fmt.Println(data) }

以上结果为

使用切片的channel就不会报死锁

go

代码解读

复制代码

package main import ( "fmt" "time" ) func main() { channels := make([]chan int, 2) for i := 0; i < 2; i++ { go func(ch chan int) { time.Sleep(time.Second) ch <- 1 }(channels[i]) } for ch := range channels { fmt.Println("执行结果为:", ch) } fmt.Println("执行结束=====================") }

chnnel可读可写

channel 可以分为 3 种类型：

• 只读 channel，单向 channel
• 只写 channel，单向 channel
• 可读可写 channel 默认情况下，都是可读可写的，如

go

代码解读

复制代码

ch := make(chan int64)

定义一个可读管道

css

代码解读

复制代码

func say(ch <-chan int) { for i := 0; i < 100; i++ { data := <-ch log.Println("结果为:", data) } }

定义一个只可写通道

css

代码解读

复制代码

func say1(ch chan<- int) { for i := 0; i < 100; i++ { ch <- i } }

使用如下

go

代码解读

复制代码

package main import ( "log" "time" ) func main() { var ch = make(chan int) go say(ch) go say1(ch) time.Sleep(5 * time.Second) } func say(ch <-chan int) { for i := 0; i < 100; i++ { data := <-ch log.Println("结果为:", data) } } func say1(ch chan<- int) { for i := 0; i < 100; i++ { ch <- i } }

chan超时

chan配合select机制可以设置阻塞超时

go

代码解读

复制代码

package main import ( "fmt" "time" ) func main() { var ch = make(chan int) go say(ch) select { case data, ok := <-ch: fmt.Println(data, ok) case <-time.After(3 * time.Second): fmt.Println("================超时") } } func say(ch chan int) { time.Sleep(5 * time.Second) ch <- 1 fmt.Println("==============执行") }

总结

合理的使用channel，在并发中更好的进行写成之间的通讯