Golang中的管道(channel) 、goroutine与channel实现并发、单向管道、select多路复用以及goroutine panic处理

落日映苍穹つ 2024-03-17 09:26 56阅读 0赞

## ![aaa4dcaa60aa43b7a59d9db505df934b.gif][] ##

**目录**

管道（channel）

无缓冲管道

有缓冲管道

需要注意

goroutine与channel实现并发

单向管道

定义单向管道

将双向管道转换为单向管道

单向管道作为函数参数

单向管道的代码示例

select多路复用

案例演示

goroutine panic处理

案例演示

--------------------

## 管道（channel） ##

管道（channel）是 Go 语言中实现并发的一种方式，它可以在多个 goroutine 之间进行通信和数据交换。管道可以看做是一个队列，通过它可以进行先进先出的数据传输，支持并发的读和写。

Go 语言中使用 make 函数来创建一个管道，它的语法如下：

ch := make(chan 数据类型)

其中，数据类型可以是任意的 Go 语言数据类型，例如 int、string 等。创建了一个管道之后，我们就可以在多个 goroutine 之间进行数据传输了。

### 无缓冲管道 ###

无缓冲管道是指在创建管道时没有指定容量，也就是说，它只能存储一个元素，当一个 goroutine 尝试向管道发送数据时，它会阻塞直到另一个 goroutine 从管道中读取数据。同样的，当一个 goroutine 尝试从管道中读取数据时，它也会阻塞直到另一个 goroutine 向管道中发送数据。

示例代码：

package main
    
    import (
        "fmt"
    )
    
    func main() {
        ch := make(chan int)
        go func() {
            ch <- 10
        }()
        fmt.Println(<-ch)
    }

创建了一个无缓冲管道 `ch`，并在一个 goroutine 中向管道中发送了一个整数 `10`。在主 goroutine 中，我们通过 `<-ch` 从管道中读取数据并打印出来。

### 有缓冲管道 ###

有缓冲管道是指在创建管道时指定了容量，这时候它可以存储多个元素，但是当管道已满时，尝试向管道发送数据的 goroutine 会被阻塞，直到另一个 goroutine 从管道中读取数据以腾出空间。同样的，当管道为空时，尝试从管道中读取数据的 goroutine 也会被阻塞，直到另一个 goroutine 向管道中发送数据。

示例代码：

package main
    
    import (
        "fmt"
    )
    
    func main() {
        ch := make(chan int, 2)
        ch <- 10
        ch <- 20
        fmt.Println(<-ch)
        fmt.Println(<-ch)
    }

创建了一个容量为 2 的有缓冲管道 `ch`，并在主 goroutine 中向管道中依次发送了整数 `10` 和 `20`。接着，我们依次从管道中读取数据并打印出来。

### 需要注意 ###

1.管道是有缓冲的，可以通过指定缓冲区大小来控制数据在管道中的流动。如果缓冲区已满，写入操作将会阻塞直到缓冲区有空间；如果缓冲区为空，读取操作将会阻塞直到有数据写入。

2.管道的写入和读取操作都是阻塞的，直到操作完成才会返回。如果需要非阻塞的读写操作，可以使用`select`语句进行多路复用。

3.管道可以被关闭，一旦管道被关闭，读取操作将不再阻塞，返回一个零值和一个标识管道已关闭的错误；写入操作将会抛出 panic。为了避免 panic，可以在写入操作之前先检查管道是否已关闭。

4.管道可以用作信号量或同步器，例如使用一个无缓冲的管道实现多个 goroutine 之间的同步。

## goroutine与channel实现并发 ##

下面是一个协程与管道实现并发的代码示例，其中使用了两个管道，一个用于发送整数数据，另一个用于接收处理后的数据：

package main
    
    import (
    	"fmt"
    )
    
    func produce(out chan<- int) {
    	for i := 0; i < 5; i++ {
    		out <- i
    	}
    	close(out)
    }
    
    func consume(in <-chan int, out chan<- int) {
    	for v := range in {
    		out <- v * v
    	}
    	close(out)
    }
    
    func main() {
    	ch1 := make(chan int)
    	ch2 := make(chan int)
    
    	go produce(ch1)
    	go consume(ch1, ch2)
    
    	for v := range ch2 {
    		fmt.Println(v)
    	}
    }

代码分析：

1.使用 `make` 函数创建了两个整数类型的管道 `ch1` 和 `ch2`。

2.使用 `go` 关键字分别启动了函数 `produce` 和 `consume` 的协程，其中函数 `produce` 向管道 `ch1` 中发送了整数数据，函数 `consume` 从管道 `ch1` 中接收数据进行处理，将处理结果发送到管道 `ch2` 中。

3.在主协程中，使用 `range` 关键字从管道 `ch2` 中循环接收处理结果，并将接收到的数据打印出来。

## 单向管道 ##

在 Go 语言中，有的时候我们会将管道作为参数在多个任务函数间传递，很多时候我们在不同的任务函数中使用管道都会对其进行限制，比如限制管道在函数中只能发送或者只能接收。

### 定义单向管道 ###

定义一个单向管道可以使用 channel 类型加上箭头运算符（<-）指定读写方向。

例如，定义一个只能写入字符串的单向管道可以使用以下语句：

var ch chan<- string

定义一个只能读出字符串的单向管道可以使用以下语句：

var ch <-chan string

### 将双向管道转换为单向管道 ###

双向管道可以转换为只读或只写的单向管道，例如，将一个双向管道转换为只读的单向管道可以使用以下语句：

var ch chan string
    var chRead <-chan string = ch

将一个双向管道转换为只写的单向管道可以使用以下语句：

var ch chan string
    var chWrite chan<- string = ch

### 单向管道作为函数参数 ###

单向管道可以作为函数参数来限制管道的读写方向。例如，以下函数接受只读的单向管道作为参数：

func readData(ch <-chan string) {
        // ...
    }

以下函数接受只写的单向管道作为参数：

func writeData(ch chan<- string) {
        // ...
    }

### 单向管道的代码示例 ###

以下是一个使用单向管道的代码示例，该示例将一个双向管道转换为只读和只写的单向管道，并将这些单向管道作为函数参数传递：

package main
    
    import "fmt"
    
    func readData(ch <-chan int) {
        for i := range ch {
            fmt.Println("Read data:", i)
        }
    }
    
    func writeData(ch chan<- int) {
        for i := 0; i < 5; i++ {
            ch <- i
        }
        close(ch)
    }
    
    func main() {
        ch := make(chan int)
        chRead := (<-chan int)(ch)
        chWrite := (chan<- int)(ch)
        go readData(chRead)
        go writeData(chWrite)
        select {}
    }

在上面的代码示例中，定义了一个双向管道 ch，然后将它转换为只读的单向管道 chRead 和只写的单向管道 chWrite，并分别将它们作为 readData 和 writeData 函数的参数传递。在 main 函数中，将 readData 和 writeData 函数放入不同的 goroutine 中运行，以便它们可以并发地读取和写入数据。最后使用 select \{\} 让主程序保持运行，以便 goroutine 可以继续运行。

## select多路复用 ##

在Go语言中，`select`语句可以用于多路复用I/O操作，其语法结构类似于`switch`语句。它可以同时监视多个管道的读写操作，并在其中一个通道满足读写条件时执行相应的操作。

`select`语句的语法如下：

select {
    case <-ch1:
        // 处理从 ch1 读取到的数据
    case data := <-ch2:
        // 处理从 ch2 读取到的数据
    case ch3 <- data:
        // 向 ch3 写入数据
    default:
        // 如果没有任何 case 语句满足条件，则执行 default 语句
    }

在`select`语句中，每个`case`分支必须是一个通道操作，要么是从通道中读取数据，要么是向通道中写入数据。其中，`default`分支是可选的，表示如果没有任何`case`语句满足条件，则执行`default`语句。

### 案例演示 ###

package main
    
    import (
        "fmt"
        "time"
    )
    
    func main() {
        ch1 := make(chan int)
        ch2 := make(chan int)
    
        go func() {
            for i := 1; i <= 5; i++ {
                ch1 <- i
                time.Sleep(time.Second)
            }
        }()
    
        go func() {
            for i := 1; i <= 5; i++ {
                ch2 <- i * i
                time.Sleep(500 * time.Millisecond)
            }
        }()
    
        for i := 0; i < 10; i++ {
            select {
            case data := <-ch1:
                fmt.Println("Received from ch1:", data)
            case data := <-ch2:
                fmt.Println("Received from ch2:", data)
            }
        }
    }

在这个示例中，我们创建了两个通道`ch1`和`ch2`，并分别向其中写入一些数据。在主函数中，我们使用`select`语句监听这两个通道，并在其中一个通道中有数据时输出该数据。由于`ch1`的写入间隔为1秒，而`ch2`的写入间隔为500毫秒，因此我们可以看到输出的数据是交替出现的。

## goroutine panic处理 ##

panic是Go语言中的一种异常处理机制，它的出现是为了让程序在遇到某些不可控制的情况时，能够快速反应，而不是无限期的等待。panic的用法有两种：一种是在程序中显式地调用panic函数，用于处理特定的异常情况；另一种是在程序运行过程中，由于某些不可控制的原因，程序自动抛出panic异常。

### 案例演示 ###

// 函数
    func sayHello() {
        for i := 0; i < 10; i++ {
            fmt.Println("hello,world")
        }
    }
    
    // 问题函数
    func test() {
        //这里使用defer + recover
        defer func() { //匿名自执行函数
            if err := recover(); err != nil {
                fmt.Println("test() 发生错误", err)
            }
        }()
        //定义一个map
        var myMap map[int]string
        myMap[0] = "hello"
    }
    
    func main() {
        //当两个协程中一个出现问题时，另一个也不会进行操作，可以使用异常处理避免
        go sayHello()
        go test()
        //防止主进程退出这里利用time.Sleep
        time.Sleep(time.Second)
    }

输出结果：

![ff6390739ff14928a293a3744a50e718.png][]

[aaa4dcaa60aa43b7a59d9db505df934b.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/fc92e69c242948ed8bd8cb583f60b38e.png
[ff6390739ff14928a293a3744a50e718.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/4598a6955db5400287eef88be7631eb4.png