golang通道|极客笔记

golang通道

在Go语言中，通道（channel）是一种用来在不同goroutine之间传递数据的数据结构。通道是并发安全的，可以保证数据的原子性操作，可以防止竞态条件的发生。

通道的声明与初始化

通道可以通过内建函数make来进行声明和初始化，语法如下：

ch := make(chan int) // 声明一个int类型的通道

我们也可以指定通道的缓冲区大小，例如：

ch := make(chan int, 10) // 声明一个int类型的通道，缓冲区大小为10

通道的发送与接收

通道有发送和接收两种操作。当我们向通道发送数据时，使用操作符<-；当我们从通道接收数据时，也使用操作符<-。例如：

// 创建一个int类型的通道
ch := make(chan int)

// 在一个goroutine中向通道发送数据
go func() {
    ch <- 1
}()

// 从通道中接收数据
data := <-ch
fmt.Println(data) // 输出：1

上面的示例中，我们在一个goroutine中向通道发送数据1，然后在主goroutine中从通道中接收数据，并输出为1。

通道的关闭

通道还有一个重要的特性，就是可以被关闭。关闭通道后，我们依然可以从通道中接收数据，但不能再向通道发送数据。通道的关闭是为了告诉接收者，发送者已经不再发送数据，这样可以让接收者知道何时停止等待。

// 创建一个字符串类型的通道
ch := make(chan string)

// 向通道发送数据
go func() {
    ch <- "hello"
    ch <- "world"
    close(ch)
}()

// 从通道中接收数据
for {
    data, ok := <-ch
    if !ok {
        break
    }
    fmt.Println(data)
}

上面的示例中，我们向通道ch发送了两条数据，然后关闭了通道。在接收数据的循环中，我们不断地从通道中接收数据，直到通道被关闭。

无缓冲通道和有缓冲通道

在实际使用中，我们可以根据需要选择使用无缓冲通道或有缓冲通道。无缓冲通道保证发送和接收操作是同步的，发送操作会阻塞，直到有goroutine从通道中接收数据；同样，接收操作也会阻塞，直到有goroutine向通道发送数据。而有缓冲通道则在满时才会阻塞发送操作，并在空时阻塞接收操作。

// 无缓冲通道
ch := make(chan int)

// 有缓冲通道
ch := make(chan int, 10)

通道的方向

通道还可以具有方向，即只能发送或只能接收。在函数的参数中，我们可以限定通道的方向，以增强代码的健壮性。

// 只能发送数据的通道
func producer(ch chan<- int) {
    ch <- 1
}

// 只能接收数据的通道
func consumer(ch <-chan int) {
    data := <-ch
    fmt.Println(data)
}

上面的示例中，我们定义了两个函数producer和consumer，分别对应只能发送数据和只能接收数据的通道。

select语句

在使用通道时，我们可能需要同时处理多个通道的数据。这时可以使用select语句，类似于switch语句，但用于通道操作。select语句会随机选择一个可用的通道进行通信。

ch1 := make(chan int)
ch2 := make(chan int)

go func() {
    ch1 <- 1
    close(ch1)
}()

go func() {
    ch2 <- 2
    close(ch2)
}()

for i := 0; i < 2; i++ {
    select {
    case data, ok := <-ch1:
        if !ok {
            continue
        }
        fmt.Println("From ch1:", data)
    case data, ok := <-ch2:
        if !ok {
            continue
        }
        fmt.Println("From ch2:", data)
    }
}

上面的示例中，我们创建了两个goroutine，分别向通道ch1和ch2发送数据，并在主goroutine中通过select语句选择可用的通道进行接收数据。

使用通道实现并发模式

通道是Go语言并发编程的重要工具之一，通过通道可以实现多个goroutine之间的通信和协作。下面是一个使用通道实现生产者-消费者模型的示例：

package main

import (
    "fmt"
)

func producer(ch chan<- int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch)
}

func consumer(ch <-chan int) {
    for data := range ch {
        fmt.Println("Consumed:", data)
    }
}

func main() {
    ch := make(chan int)

    go producer(ch)
    go consumer(ch)

    // 等待goroutine执行结束
    var input string
    fmt.Scanln(&input)
}

在上面的示例中，我们定义了生产者和消费者两个函数，并在main函数中创建了一个通道ch。通过go关键字可以启动生产者和消费者两个goroutine，并通过通道进行数据交互。