本文内容纲要：
- channel基本语法
- • channel介绍
- • channel声明语法
- ▶ 语法如下
- ▶ 示例如下
- • channel定义语法
- ▶ 语法如下
- • channel关闭语法
- • channel读写语法
- ▶ range操作
- ▶ select操作
- ▶ 判断channel关闭
- • 单向channel语法
- ▶ 使用意义
- ▶ 声明语法
- ▶ 类型转换
- ▶ 示例如下
- channel实际运用
- • 主函数等待所有goroutine完成后返回
- ▶ 使用意义
- ▶ 使用示例
- • 实现IO超时机制
- ▶ 使用意义
- ▶ 使用示例
• channel介绍
√ golang社区口号：不要通过共享内存来通信，而应该通过通信来共享内存。
√ golang提供一种基于消息机制而非共享内存的通信模型。消息机制认为每个并发单元都是自包含的独立个体，并且拥有自己的变量，但在不同并发单元间这些变量不共享。每个并发单元的输入和输出只有一种，那就是消息。
√ channel是golang在语言级提供的goroutine间的通信方式，可以使用channel在两个或多个goroutine之间传递消息。
√ channel是进程内的通信方式，如果需要跨进程通信，建议使用分布式的方法来解决，比如使用Socket或HTTP等通信协议。
√ channel是类型相关的，即一个channel只能传递一种类型的值，需要在声明channel时指定。可以认为channel是一种类型安全的管道。
• channel声明语法
▶ 语法如下
var chanName chan ElementType
▶ 示例如下
var ch chan int // int类型channel
var m map[string]chan bool // bool类型channel的map
• channel定义语法
▶ 语法如下
√ 定义一个channel直接使用内置的函数make()即可。
// 声明一个channel
var chanName chan ElementType
// 定义一个无缓冲的channel
chanName := make(chan ElementType)
// 定义一个带缓冲的channel
chanName := make(chan ElementType, n)
• channel关闭语法
√ 关闭一个channel直接使用内置的函数close()即可。
√ 应该在生产者处关闭channel，而不是消费者处关闭channel，否则容易引起panic。
// 声明一个channel
var chanName chan ElementType
// 定义一个无缓冲的channel
chanName := make(chan ElementType)
// 定义一个带缓冲的channel
chanName := make(chan ElementType, n)
// 关闭一个channel
close(chanName)
• channel读写语法
√ 向无缓冲的channel写入数据会导致该goroutine阻塞，直到其他goroutine从这个channel中读取数据。
√ 向带缓冲的且缓冲已满的channel写入数据会导致该goroutine阻塞，直到其他goroutine从这个channel中读取数据。
√ 向带缓冲的且缓冲未满的channel写入数据不会导致该goroutine阻塞。
√ 从无缓冲的channel读出数据，如果channel中无数据，会导致该goroutine阻塞，直到其他goroutine向这个channel中写入数据。
√ 从带缓冲的channel读出数据，如果channel中无数据，会导致该goroutine阻塞，直到其他goroutine向这个channel中写入数据。
√ 从带缓冲的channel读出数据，如果channel中有数据，该goroutine不会阻塞。
√ 总结：无缓冲的channel读写通常都会发生阻塞，带缓冲的channel在channel满时写数据阻塞，在channel空时读数据阻塞。
// 声明一个channel
var chanName chan ElementType
// 定义一个无缓冲的channel
chanName := make(chan ElementType)
// 定义一个带缓冲的channel
chanName := make(chan ElementType, n)
// 写channel
chanName <- value
// 读channel
value := <-chanName
▶ range操作
√ golang中的range常常和channel一起使用，用来从channel中读取所有值。
√ range操作能够不断读取channel里面的数据，直到该channel被显式的关闭。
▪ 语法如下
for value := range chanName {
// ...
}
▪ 示例如下
package main
import "fmt"
func generateString(strings chan string) {
strings <- "Monday"
strings <- "Tuesday"
strings <- "Wednesday"
strings <- "Thursday"
strings <- "Friday"
strings <- "Saturday"
strings <- "Sunday"
close(strings)
}
func main() {
strings := make(chan string) // 无缓冲channel
go generateString(strings)
for s := range strings {
fmt.Println(s)
}
}
▶ select操作
√ golang中的select关键字用于处理异步IO，可以与channel配合使用。
√ golang中的select的用法与switch语言非常类似，不同的是select每个case语句里必须是一个IO操作。
√ select会一直等待等到某个case语句完成才结束。
▪ 语法如下
select {
case <-chan1:
// 如果chan1成功读到数据，则进行该case处理语句
case chan2 <- 1:
// 如果成功向chan2写入数据，则进行该case处理语句
default:
// 如果上面都没有成功，则进入default处理流程
}
▪ 示例如下
package main
import "fmt"
import "time"
func main() {
timeout := make(chan bool)
go func() {
time.Sleep(3 * time.Second) // sleep 3 seconds
timeout <- true
}()
// 实现了对ch读取操作的超时设置。
ch := make(chan int)
select {
case <-ch:
case <-timeout:
fmt.Println("timeout!")
}
}
▶ 判断channel关闭
√ 在读取的时候使用多重返回值来判断一个channel是否已经被关闭。
▪ 语法如下
value, ok := <-chanName
if ok {
// channel未关闭
} else {
// channel已关闭
}
▪ 示例如下
package main
import "fmt"
func generateString(strings chan string) {
strings <- "Monday"
strings <- "Tuesday"
strings <- "Wednesday"
strings <- "Thursday"
strings <- "Friday"
strings <- "Saturday"
strings <- "Sunday"
close(strings)
}
func main() {
strings := make(chan string) // 无缓冲channel
go generateString(strings)
for {
if s, ok := <-strings; ok {
fmt.Println(s)
} else {
fmt.Println("channel colsed.")
break
}
}
}
• 单向channel语法
▶ 使用意义
√ golang中假如一个channel只允许读，那么channel肯定只会是空的，因为没机会往里面写数据。
√ golang中假如一个channel只允许写，那么channel最后只会是满的，因为没机会从里面读数据。
√ 单向channel概念，其实只是对channel的一种使用限制，即在将一个channel变量传递到一个函数时，可以通过将其指定为单向channel变量，从而限制该函数中可以对此channel的操作，达到权限控制作用。
▶ 声明语法
var ch1 chan elementType // ch1是一个正常的channel
var ch2 chan<- elementType // ch2是单向channel，只用于写数据
var ch3 <-chan elementType // ch3是单向channel，只用于读数据
▶ 类型转换
ch1 := make(chan elementType)
ch2 := <-chan elementType(ch1) // ch2是一个单向的读取channel
ch3 := chan<- elementType(ch1) // ch3是一个单向的写入channel
▶ 示例如下
package main
import "fmt"
func Parse(ch <-chan int) {
for value := range ch {
fmt.Println("Parsing value", value)
}
}
func main() {
var ch chan int
ch = make(chan int)
go func() {
ch <- 1
ch <- 2
ch <- 3
close(ch)
}()
Parse(ch)
}
• 主函数等待所有goroutine完成后返回
▶ 使用意义
我们已经知道golang程序从main()函数开始执行，当main()函数返回时，程序结束且不等待其他goroutine结束。如果main函数使用time.Sleep方式阻塞等待所有goroutine返回，那么这个休眠时间势必无法控制精确。通过使用channel可以很好解决这个问题。
▶ 使用示例
package main
import "fmt"
func MyRoutineFunc(ch chan int) {
// 函数处理
ch <- 1
fmt.Println("MyRoutineFunc process finished.")
}
func main() {
chs := make([]chan int, 10)
for i := 0; i < 10; i++ {
chs[i] = make(chan int)
go MyRoutineFunc(chs[i])
}
for _, ch := range chs {
<-ch
}
fmt.Println("All goroutine finished.")
}
• 实现IO超时机制
▶ 使用意义
golang没有提供直接的超时处理机制，但我们可以利用select和channel结合来实现超时机制。
▶ 使用示例
package main
import "fmt"
import "time"
func main() {
// 实现并执行一个匿名的超时等待函数
timeout := make(chan bool, 1)
go func() {
time.Sleep(3 * time.Second) // 等待3秒钟
timeout <- true
}()
// 然后结合使用select实现超时机制
ch := make(chan int)
select {
case <-ch:
// 从ch中读取到数据
case <-timeout:
// 一直没有从ch中读取到数据，但从timeout中读取到了数据
fmt.Println("timeout!")
}
}
本文内容总结：channel基本语法，• channel介绍，• channel声明语法，▶ 语法如下，▶ 示例如下，• channel定义语法，▶ 语法如下，• channel关闭语法，• channel读写语法，▶ range操作，▶ select操作，▶ 判断channel关闭，• 单向channel语法，▶ 使用意义，▶ 声明语法，▶ 类型转换，▶ 示例如下，channel实际运用，• 主函数等待所有goroutine完成后返回，▶ 使用意义，▶ 使用示例，• 实现IO超时机制，▶ 使用意义，▶ 使用示例，