【Go】十八、管道

1、管道

• channel
• 本质是一个队列，先进先出
• 自身线程安全，多协程访问时，不用加锁，channel本身就是线程安全的
• 一个string的管道只能存放string类型数据

2、管道的定义

var  变量名  chan  数据类型
1

• chan是管道的关键字
• 数据类型，比如int类型的管道只能写入整数int
• 管道是引用类型，必须初始化才能写入数据，即make后才能使用
• 管道中不能存放大于容量的数据
• 在没有使用协程的情况下，如果管道的数据已经全部取出，那么再取就会报错

示例：

package main
import(
        "fmt"
)
func main(){
        //定义管道 、 声明管道 ---> 定义一个int类型的管道
        var intChan chan int
        //通过make初始化：管道可以存放3个int类型的数据
        intChan = make(chan int,3)
        //证明管道是引用类型：
        fmt.Printf("intChan的值：%v",intChan) // 0xc000112080
        //向管道存放数据：
        intChan<- 10
        num := 20
        intChan<- num
        intChan<- 40  
        //注意：不能存放大于容量的数据：
        //intChan<- 80  
        //在管道中读取数据：
        num1 := <-intChan
        num2 := <-intChan
        num3 := <-intChan
        fmt.Println(num1)
        fmt.Println(num2)
        fmt.Println(num3)
        //注意：在没有使用协程的情况下，如果管道的数据已经全部取出，那么再取就会报错：
        num4 := <-intChan
        fmt.Println(num4)
        //输出管道的长度：
        fmt.Printf("管道的实际长度：%v,管道的容量是：%v",len(intChan),cap(intChan))
}
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

3、管道的关闭

使用内置函数close可以关闭管道，当管道关闭后，就不能再向管道写数据了，但是仍然可以从该管道读取数据

package main
import(
        "fmt"
)
func main(){
        //定义管道 、 声明管道
        var intChan chan int
        //通过make初始化：管道可以存放3个int类型的数据
        intChan = make(chan int,3)
        //在管道中存放数据：
        intChan<- 10
        intChan<- 20
        //关闭管道：
        close(intChan)
        //再次写入数据：--->报错
        //intChan<- 30
        //当管道关闭后，读取数据是可以的：
        num := <- intChan
        fmt.Println(num)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4、管道的遍历

• for
• for-range

在遍历时，如果管道没有关闭，则报错：

package main
import(
        "fmt"
)
func main(){
        //定义管道 、 声明管道
        var intChan chan int
        //通过make初始化：管道可以存放100个int类型的数据
        intChan = make(chan int,100)
        for i := 0;i < 100;i++ {
                intChan<- i
        }
        //在遍历前，如果没有关闭管道，就会出现deadlock的错误
        //所以我们在遍历前要进行管道的关闭
        close(intChan)
        //遍历：for-range
        for v := range intChan {
                fmt.Println("value = ",v)
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

5、管道 + 协程

• 开启一个writeData协程，向管道中写入50个整数.
• 开启一个readData协程，从管道中读取writeData写入的数据

package main
import(
        "fmt"
        "time"
        "sync"
)
var wg sync.WaitGroup //只定义无需赋值

//写：
func writeData(intChan chan int){
        defer wg.Done()
        for i := 1;i <= 50;i++{
                intChan<- i
                fmt.Println("写入的数据为：",i)
                time.Sleep(time.Second)
        }
        //管道关闭：
        close(intChan)
}

//读：
func readData(intChan chan int){
        defer wg.Done()
        //遍历：
        for v := range intChan{
                fmt.Println("读取的数据为：",v)
                time.Sleep(time.Second)
        }
}

func main(){//主线程
        //写协程和读协程共同操作同一个管道-》定义管道：
        intChan := make(chan int,50)
        wg.Add(2)
        //开启读和写的协程：
        go writeData(intChan)
        go readData(intChan)
        //主线程一直在阻塞，什么时候wg减为0了，就停止
        wg.Wait()	
}
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
35
36
37
38
39
40

运行：

在没有使用协程的情况下，如果管道的数据已经全部取出，那么再取就会报错。所以上面即使写入后sleep两秒，读取也不会报错。

6、只读、只写管道

package main
import(
        "fmt"
)
func main(){
        //默认情况下，管道是双向的--》可读可写：
        //var intChan1 chan int
        //声明为只写：
        var intChan2 chan<- int  // 管道具备<- 只写性质
        intChan2 = make(chan int,3)
        intChan2<- 20
        //num := <-intChan2 报错
        fmt.Println("intChan2:",intChan2)
        //声明为只读：
        var intChan3 <-chan int// 管道具备<- 只读性质 
        if intChan3 != nil {	//非空
                num1 := <-intChan3
                fmt.Println("num1:",num1)
        }
        //intChan3<- 30 报错
        
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

7、管道的阻塞

管道只写入数据，不读取，超过容量：

package main
import(
        "fmt"
        _"time"
        "sync"
)
var wg sync.WaitGroup //只定义无需赋值

//写：
func writeData(intChan chan int){
        defer wg.Done()
        for i := 1;i <= 20;i++{   //超过容量管道的容量10
                intChan<- i
                fmt.Println("写入的数据为：",i)
                //time.Sleep(time.Second)
        }
        //管道关闭：
        close(intChan)
}

func main(){//主线程
        //定义管道：
        intChan := make(chan int,10)
        wg.Add(1)
        //开启写的协程：
        go writeData(intChan)
        wg.Wait()	
}
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

改一下，写的快，读的慢：没报错，但很明显，写被影响了，到最后被动等读协程，读走一个，写协程才能继续写。

8、select

• 从多个管道中进行非阻塞的选择
• select同时监听多个管道的数据流通，并在其中任意一个管道有数据可读或者可写的时候做相应的处理

select {
case <- channel1:
    // 处理channel1的数据
case data := <- channel2:
    // 处理channel2的数据
case channel3 <- value:
    // 向channel3发送数据
default:
    // 当没有任何通道准备就绪时执行default块
}
1
2
3
4
5
6
7
8
9
10

按顺序检查有没那个case后面的管道是可读或者可写的，有则执行该case语句。如果多个case同时满足，Go会随机选择一个执行。

如果没有任何case语句满足条件，且存在default语句，则执行default块中的代码。如果没有default语句，则select语句会被阻塞，直到至少有一个case语句满足条件。

package main
import(
        "fmt"
        "time"
)
func main(){
        //定义一个int管道：
        intChan := make(chan int,1)
        go func(){
                time.Sleep(time.Second * 5)
                intChan<- 10
        }()
        //定义一个string管道：
        stringChan := make(chan string,1)
        go func(){
                time.Sleep(time.Second * 2)
                stringChan<- "msbgolang"
        }()
        //fmt.Println(<-intChan)//本身取数据就是阻塞的
        select{
                case v := <-intChan :
                        fmt.Println("intChan:",v)
                case v := <-stringChan :
                        fmt.Println("stringChan:",v)
                default:
                        fmt.Println("防止select被阻塞")
        }
}
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

输出：

防止select被阻塞
1

上面两个case的协程都不能立即可读或可写，走了default。没有default，则输出：

msbgolang
1

因为其对应的管道阻塞时间短，2s后就可以读到了