Channel的定义、写入、读取、关闭与遍历
目录
- 1.Channel基础
-
- 为什么要引入Channel ？
- Channel简介
- channel的定义/声明
- channel的数据类型：引用类型
- 向channel中写入数据
- 从channel中读取数据
- 2 channel的遍历与关闭
-
- channel的关闭
-
- 使用内置函数close关闭channel
- 向已关闭的channel中继续写入数据
- channel的遍历
-
- channel遍历的方式
-
- 1.使用 range 关键字遍历 channel
- 2.使用 for 循环和 select 语句遍历 channel
- 3 使用 len 函数和 for 循环遍历 channel（难点）
-
- 1) i < len(intChan) 陷入死循环
- 解决方案1：使用cap(intChan)函数获取channel的容量
- 2) 只等读到一半的数据
- 解决方案2：for len(ch) > 0 {}
- 遍历时，如果channel没有关闭，则会出现deadlock的错误
- 3 实例演示：定义map型channel，并进行数据的读写
-
- map型channel
- map型channel2:
- Struct型channel
- 通过空接口实现存放任意数据类型的channel
- 空接口型channel与类型断言
1.Channel基础
为什么要引入Channel ？
- 使用全局变量加锁同步可以来解决goroutine的通讯，但不完美，原因如下：
- 主线程在等待所有goroutine全部完成的时间很难确定，我们这里设置10秒，只能估算。如果主线程休眠时间长了，会加长等待时间，如果等待时间短了，可能还有goroutine处于工作状态，这时也会随主线程的退出而销毁。通过全局变量加锁同步来实现通讯，也并不利于多个协程对全局变量的读写操作。所以需要一个新的通讯机制来实现自动实现goroutine之间的通讯，主线程可以自动捕获goroutine结束，channel即可满足这种需求
Channel简介
- channle本质就是一个数据结构-队列
- 数据是先进先出【FIFO：first in first out】
- 线程安全，多goroutine 访问时，不需要加锁，就是说channel 本身就是线程安全的
- channel有类型的，一个string的channel只能存放 string类型数据。
channel的定义/声明
var 变量名 chan 变量类型
//channel是有类型的intChan 只能写入整数int
var intchan chan int
//mapChan用于存放map[int]string类型
var mapchan chan map[int]string
channel 必须初始化才能写入数据，即make后才能使用
//创建一个可以存放3个int类型的管道
intChan = make(chan int, 3)
声明的同时初始化
// 创建容量为 10 的 channel
mapchan := make(chan map[string]string, 10)
channel的数据类型：引用类型
//看看intChan是什么
fmt.Printf("intChan 的值=%v intChan本身的地址=%p\n", intChan, &intChan)
intChan 的值=0xc000108080 intChan本身的地址=0xc00000a028
//intchan 指向存放数据的地址
向channel中写入数据
int型
// 向管道写入数据
intChan<- 10
num := 211
intChan<- num
intChan<- 50
// 如果从channel取出数据后，可以继续放入
<-intChan
intChan<- 98
//注意点, 当我们给管道中写入数据时，不能超过其容量，数据放满后就不能再放入了
从channel中读取数据
//从管道中读取数据
var num2 int
num2 = <-intChan
fmt.Println("num2=", num2)
fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan)) // 2, 3
num3 := <-intChan
num4 := <-intChan
fmt.Println("num3=", num3, "num4=", num4) // num3= 50 num4= 98
// 在没有使用协程的情况下，如果我们的管道数据已经全部取出，再取就会报告 deadlock
//num5 := <-intChan
// fmt.Println( "num5=", num5)
//fatal error: all goroutines are asleep - deadlock!
2 channel的遍历与关闭
channel的关闭
使用内置函数close关闭channel
使用内置函数close可以关闭channel,当channel关闭后，就不能再向channel写数据了，但是仍然
可以从该channel读取数据。
在 Go 中，我们可以使用内置函数 close 来关闭一个 channel。关闭一个 channel 后，就不能再向该 channel 中写入数据了，但仍然可以从该 channel 中读取数据。当从一个已经关闭的 channel 中读取数据时，会得到该 channel 类型的零值。
一个如何关闭channel的例子
package main
import "fmt"
func main() {
// 创建一个容量为 10 的整数类型的 channel
intChan := make(chan int, 10)
// 向 channel 中写入 5 个整数
for i := 1; i <= 5; i++ {
intChan <- i
}
// 关闭 channel
close(intChan)
// 从 channel 中读取所有整数
for {
// 从 channel 中读取一个整数
value, ok := <-intChan
// 如果 channel 已经关闭且里面没有数据了，就退出循环
if !ok {
break
}
// 输出读取的整数
fmt.Printf("Read a value from intChan: %d\n", value)
}
// 再次从 channel 中读取数据，会得到零值
value, ok := <-intChan
fmt.Printf("Read a value from intChan after close: %d, %v\n", value, ok)
}
在这段代码中，我们创建了一个容量为 10 的整数类型的 channel intChan。然后我们向 intChan channel 中写入了 5 个整数。接着，我们使用 close 函数关闭了 intChan channel。最后，我们使用一个循环从 intChan channel 中读取所有整数，并将它们输出。在读取完所有整数后，我们再次从 intChan channel 中读取数据，这时会得到一个整数类型的零值和一个表示 channel 是否关闭的布尔值 false。
输出结果如下：
Read a value from intChan: 1
Read a value from intChan: 2
Read a value from intChan: 3
Read a value from intChan: 4
Read a value from intChan: 5
Read a value from intChan after close: 0, false
向已关闭的channel中继续写入数据
在 Go 中，当一个 channel 被关闭后，就不能再向该 channel 中写入数据了，否则会导致 panic。
下面是一个演示如何关闭 channel 的例子，同时在关闭后向该 channel 写入数据：
package main
import "fmt"
func main() {
// 创建一个容量为 10 的整数类型的 channel
intChan := make(chan int, 10)
// 向 channel 中写入 5 个整数
for i := 1; i <= 5; i++ {
intChan <- i
}
// 关闭 channel
close(intChan)
// 向已关闭的 channel 写入数据，会导致 panic
intChan <- 6
fmt.Println("write data to closed channel")
// 从 channel 中读取所有整数
for {
// 从 channel 中读取一个整数
value, ok := <-intChan
// 如果 channel 已经关闭且里面没有数据了，就退出循环
if !ok {
break
}
// 输出读取的整数
fmt.Printf("Read a value from intChan: %d\n", value)
}
}
运行上面的代码会产生如下的 panic 信息：
panic: send on closed channel
goroutine 1 [running]:
main.main()
/path/to/main.go:15 +0x10b
exit status 2
可以看到，向已关闭的 channel 中写入数据会导致 panic，程序崩溃。
在这段代码中，我们创建了一个容量为 10 的整数类型的 channel intChan。然后我们向 intChan channel 中写入了 5 个整数。接着，我们使用 close 函数关闭了 intChan channel。接着，我们向已关闭的 intChan channel 中写入了整数 6，这时会导致 panic。最后，我们使用一个循环从 intChan channel 中读取所有整数，并将它们输出。
channel的遍历
channel遍历的方式
在 Go 中，可以通过 for 循环遍历 channel 中的数据，有以下几种方式：
1.使用 range 关键字遍历 channel
// 创建一个容量为 3 的整数类型的 channel
intChan := make(chan int, 3)
// 向 channel 中写入 3 个整数
intChan <- 1
intChan <- 2
intChan <- 3
// 使用 range 关键字遍历 channel
for value := range intChan {
fmt.Printf("Read a value from intChan: %d\n", value)
}
在这段代码中，我们创建了一个容量为 3 的整数类型的 channel intChan，并向其中写入了 3 个整数。接着，我们使用 range 关键字遍历了 intChan channel 中的所有数据，并将它们输出。当 channel 被关闭后，使用 range 关键字遍历 channel 会自动退出循环。
2.使用 for 循环和 select 语句遍历 channel
// 创建一个容量为 3 的整数类型的 channel
intChan := make(chan int, 3)
// 向 channel 中写入 3 个整数
intChan <- 1
intChan <- 2
intChan <- 3
// 使用 for 循环和 select 语句遍历 channel
for {
select {
case value, ok := <-intChan:
// 如果 channel 已经关闭且里面没有数据了，就退出循环
if !ok {
return
}
// 输出读取的整数
fmt.Printf("Read a value from intChan: %d\n", value)
}
}
在这段代码中，我们创建了一个容量为 3 的整数类型的 channel intChan，并向其中写入了 3 个整数。接着，我们使用 for 循环和 select 语句遍历了 intChan channel 中的所有数据，并将它们输出。当 channel 被关闭后，使用 for 循环和 select 语句遍历 channel 需要手动退出循环。
3 使用 len 函数和 for 循环遍历 channel（难点）
1) i < len(intChan) 陷入死循环
// 创建一个容量为 3 的整数类型的 channel
intChan := make(chan int, 3)
// 向 channel 中写入 3 个整数
intChan <- 1
intChan <- 2
intChan <- 3
// 使用 len 函数和 for 循环遍历 channel
for i := 0; i < len(intChan); i++ {
// 从 channel 中读取一个整数
value := <-intChan
// 输出读取的整数
fmt.Printf("Read a value from intChan: %d\n", value)
}
在这段代码中，我们创建了一个容量为 3 的整数类型的 channel intChan，并向其中写入了 3 个整数。接着，我们使用 len 函数和 for
但是，这段代码会输出前两个整数，然后进入死循环，因为在for循环中使用了len(intChan)作为循环条件，但是在循环的过程中我们不断地从channel中读取数据，导致channel的长度始终保持为1，不会发生变化，从而导致for循环无法退出。
解决方案1：使用cap(intChan)函数获取channel的容量
正确的做法是在循环条件中使用cap(intChan)函数获取channel的容量，如下所示：
// 创建一个容量为 3 的整数类型的 channel
intChan := make(chan int, 3)
// 向 channel 中写入 3 个整数
intChan <- 1
intChan <- 2
intChan <- 3
// 使用 len 函数和 for 循环遍历 channel
for i := 0; i < cap(intChan); i++ {
// 从 channel 中读取一个整数
value := <-intChan
// 输出读取的整数
fmt.Printf("Read a value from intChan: %d\n", value)
}
这样就可以正确地遍历整个channel，输出所有的整数了。
2) 只等读到一半的数据
package main
import "fmt"
func main() {
// 创建一个容量为 3 的整数类型的 channel
ch := make(chan int, 30)
// 向 channel 中写入 30 个整数
for i := 0; i < 30; i++ {
ch <- i
}
close(ch)
// 使用 len 函数和 for 循环遍历 channel
for i := 0; i < len(ch); i++ {
// 从 channel 中读取一个整数
value := <-ch
// 输出读取的整数
fmt.Printf("Read a value from intChan: %d\n", value)
}
//for len(ch) > 0 {
// fmt.Println(<-ch)
//}
}
输出结果
Read a value from intChan: 0
Read a value from intChan: 1
Read a value from intChan: 2
Read a value from intChan: 3
Read a value from intChan: 4
Read a value from intChan: 5
Read a value from intChan: 6
Read a value from intChan: 7
Read a value from intChan: 8
Read a value from intChan: 9
Read a value from intChan: 10
Read a value from intChan: 11
Read a value from intChan: 12
Read a value from intChan: 13
Read a value from intChan: 14
解决方案2：for len(ch) > 0 {}
如何使用len（）得到正确结果
for len(ch) > 0{}
package main
import "fmt"
func main() {
// 创建一个容量为 3 的整数类型的 channel
ch := make(chan int, 30)
// 向 channel 中写入 30 个整数
for i := 0; i < 30; i++ {
ch <- i
}
close(ch)
// 使用 len 函数和 for 循环遍历 channel
//for i := 0; i < len(ch); i++ {
// // 从 channel 中读取一个整数
// value := <-ch
// // 输出读取的整数
// fmt.Printf("Read a value from intChan: %d\n", value)
//}
for len(ch) > 0 {
value := <-ch
// 输出读取的整数
fmt.Printf("Read a value from intChan: %d\n", value)
}
}
结果如下
Read a value from intChan: 0
Read a value from intChan: 1
Read a value from intChan: 2
Read a value from intChan: 3
Read a value from intChan: 4
Read a value from intChan: 5
Read a value from intChan: 6
Read a value from intChan: 7
Read a value from intChan: 8
Read a value from intChan: 9
Read a value from intChan: 10
Read a value from intChan: 11
Read a value from intChan: 12
Read a value from intChan: 13
Read a value from intChan: 14
Read a value from intChan: 15
Read a value from intChan: 16
Read a value from intChan: 17
Read a value from intChan: 18
Read a value from intChan: 19
Read a value from intChan: 20
Read a value from intChan: 21
Read a value from intChan: 22
Read a value from intChan: 23
Read a value from intChan: 24
Read a value from intChan: 25
Read a value from intChan: 26
Read a value from intChan: 27
Read a value from intChan: 28
Read a value from intChan: 29
思考：channel的遍历中for len(ch) > 0{ } 能得到全部结果，然而for i := 0; i < len(ch); i++{ }只能得到一半结果
在使用for i := 0; i < len(ch); i++遍历channel时，由于channel在遍历过程中长度是动态变化的，因此可能只能读取到channel的一部分数据。具体来说，当channel中的数据量大于循环开始时的长度时，只能读取到前一半的数据。同时，如前面例子所示，当len(ch)=3时，会陷入死循环。
相比之下，for len(ch) > 0 {} 的循环条件是根据 channel 的实际长度来判断的，因此只要 channel 中还有元素，循环就会继续执行，直到 channel 中的所有元素都被读取完毕。因此，这种方式可以保证读取到全部的结果。
遍历时，如果channel没有关闭，则会出现deadlock的错误
channel支持for–range的方式进行遍历，请注意两个细节
- 在遍历时，如果channel 已经关闭，则会正常遍历数据，遍历完后，就会退出遍历。如前文所述；
2）在遍历时，如果channel没有关闭，则回出现deadlock的错误
一个会导致deadlock错误的例子：
package main
import "fmt"
func main() {
ch := make(chan int)
ch <- 1
ch <- 2
ch <- 3
for i := range ch {
fmt.Println(i)
}
}
在这个例子中，我们创建了一个int类型的channel，并向该channel中写入了三个数据。然后我们使用for range循环遍历该channel，并输出其中的数据。但是由于我们没有关闭channel，当循环遍历完前三个数据后，程序会一直阻塞等待新的数据，导致deadlock错误。
fatal error: all goroutines are asleep - deadlock!
为了避免这种错误，我们可以使用close函数在遍历完所有数据后手动关闭channel，例如：
package main
import "fmt"
func main() {
ch := make(chan int)
ch <- 1
ch <- 2
ch <- 3
close(ch)
for i := range ch {
fmt.Println(i)
}
}
在这个例子中，我们在循环遍历之前，使用close函数手动关闭了channel。这样，在遍历完所有数据后，for range循环会自动退出，避免了deadlock错误的发生。
3 实例演示：定义map型channel，并进行数据的读写
map型channel
package main
import "fmt"
func main() {
ch := make(chan map[string]string, 10) // 创建容量为 10 的 channel
// 向 channel 中输入 6 个数据
for i := 1; i <= 6; i++ {
data := make(map[string]string)
data["key"] = fmt.Sprintf("value %d", i)
ch <- data
}
// 从 channel 中取出并输出 6 个数据
for i := 1; i <= 6; i++ {
data := <-ch
fmt.Println(data["key"])
}
}
value 1
value 2
value 3
value 4
value 5
value 6
map型channel2:
package main
import "fmt"
func main() {
mapchan := make(chan map[string]string, 10) // 创建容量为 10 的 channel
// 创建两个 map 变量 m1 和 m2，并向其中各写入 5 个数据
m1 := make(map[string]string, 20)
m1["key1"] = "value1"
m1["key2"] = "value2"
m1["key3"] = "value3"
m1["key4"] = "value4"
m1["key5"] = "value5"
m2 := make(map[string]string, 20)
m2["key6"] = "value6"
m2["key7"] = "value7"
m2["key8"] = "value8"
m2["key9"] = "value9"
m2["key10"] = "value10"
// 将 m1 和 m2 中的数据写入到 mapchan channel 中
mapchan <- m1
mapchan <- m2
// 从 mapchan channel 中取出并输出所有数据
for len(mapchan) > 0 {
m := <-mapchan
for k, v := range m {
fmt.Printf("%s: %s\n", k, v)
}
}
}
输出结果
key1: value1
key2: value2
key3: value3
key4: value4
key5: value5
key6: value6
key7: value7
key8: value8
key9: value9
key10: value10
在这段代码中，我们创建了一个容量为 10 的 mapchan channel，并创建了两个 map 变量 m1 和 m2，每个变量中各包含 5 个键值对。接下来，将 m1 和 m2 中的数据分别写入到 mapchan channel 中。然后使用一个循环从 mapchan channel 中读取数据，直到 channel 中没有剩余的数据。在循环体中，我们取出 channel 中的一个 map 变量 m，并遍历其中的键值对并输出它们。需要注意的是，在循环中我们使用 len(mapchan) > 0 来判断 channel 中是否还有剩余的数据，因为 len(mapchan) 表示 channel 中剩余的数据数量。由于我们在循环体中读取了所有数据，因此在循环结束后，mapchan channel 中不再有任何数据。
Struct型channel
package main
import "fmt"
type Person struct {
Name string
Age int
}
func main() {
// 创建一个容量为 3 的 Person 类型的 channel
personChan := make(chan Person, 3)
// 向 channel 中写入 3 个 Person 类型的变量
person1 := Person{"Tom", 18}
person2 := Person{"Jerry", 19}
person3 := Person{"Mike", 20}
personChan <- person1
personChan <- person2
personChan <- person3
// 从 channel 中取出并输出所有 Person 类型的变量
for len(personChan) > 0 {
person := <-personChan
fmt.Printf("Name: %s, Age: %d\n", person.Name, person.Age)
}
}
通过空接口实现存放任意数据类型的channel
可以存放任意数据类型的channel:通过空接口实现
在下面这个例子中，我们将多个不同类型的数据写入了 dataChan channel，然后按照它们写入的顺序一个一个地取出来。输出结果显示了每个元素的值，其中包括整数、字符串、布尔值、浮点数、整数数组、空的映射、包含一个整数字段的结构体、空指针、字节数组以及包含字符串、整数和布尔值的接口切片。由于我们使用了 interface{} 类型，可以存储任何类型的数据。
package main
import "fmt"
func main() {
// 创建一个容量为 10 的 interface{} 类型的 channel
dataChan := make(chan interface{}, 10)
// 向 channel 中写入 10 个任意类型的数据
dataChan <- 1
dataChan <- "hello"
dataChan <- true
dataChan <- 3.14
dataChan <- []int{1, 2, 3}
dataChan <- make(map[string]int)
dataChan <- struct{ X int }{X: 10}
dataChan <- nil
dataChan <- []byte("world")
dataChan <- []interface{}{"a", 1, false}
// 从 channel 中取出并输出所有数据
for len(dataChan) > 0 {
data := <-dataChan
fmt.Printf("%v\n", data)
}
}
1
hello
true
3.14
[1 2 3]
map[]
{10}
<nil>
[119 111 114 108 100]
[a 1 false]
空接口型channel与类型断言
在 Go 中，我们可以使用空接口类型 interface{} 表示任意类型的值。当我们将一个具体类型的值存储到空接口类型的变量中时，这个变量会自动地被转换为 interface{} 类型。但是，在从空接口类型的变量中取出具体类型的值时，我们需要使用类型断言来将其转换回原来的类型。
下面是一个在空接口类型的 channel 中使用类型断言的例子：
package main
import "fmt"
func main() {
// 创建一个容量为 10 的空接口类型的 channel
dataChan := make(chan interface{}, 10)
// 将多个不同类型的数据写入 channel 中
dataChan <- 1
dataChan <- "hello"
dataChan <- []int{1, 2, 3}
dataChan <- struct{ X int }{X: 10}
// 从 channel 中取出数据并进行类型断言
for len(dataChan) > 0 {
data := <-dataChan
switch v := data.(type) {
case int:
fmt.Printf("Got an int: %d\n", v)
case string:
fmt.Printf("Got a string: %s\n", v)
case []int:
fmt.Printf("Got an int slice: %v\n", v)
case struct{ X int }:
fmt.Printf("Got a struct: %+v\n", v)
default:
fmt.Printf("Got something else: %v\n", v)
}
}
}
在这段代码中，我们创建了一个容量为 10 的空接口类型的 channel dataChan。然后我们向 dataChan channel 中写入了 4 个不同类型的数据，包括 int、string、[]int 和 struct{X int}。最后，我们使用一个循环从 dataChan channel 中取出所有数据，并根据其类型进行类型断言。如果数据是 int 类型，我们就输出 "Got an int: " 和该值；如果数据是 string 类型，我们就输出 "Got a string: " 和该值；以此类推。
输出结果如下：
Got an int: 1
Got a string: hello
Got an int slice: [1 2 3]
Got a struct: {X:10}
在这个例子中，我们使用了类型断言来将从 dataChan channel 中取出的值转换回原来的类型。由于我们在写入数据时将它们转换成了空接口类型，因此在取出数据时需要使用类型断言将它们转换回原来的类型。