Go 通道channel

简介[编辑 | 编辑源代码]

Go通道（Channel）是Go语言中用于实现并发编程的核心机制之一，提供了一种安全、高效的方式在协程（Goroutine）之间传递数据。通道是类型化的管道，遵循先进先出（FIFO）原则，并内置同步机制，确保数据交换的线程安全。

基本语法与操作[编辑 | 编辑源代码]

通道通过`chan`关键字声明，使用`make`函数初始化。通道支持两种主要操作：

发送：使用`<-`运算符将数据写入通道（如`ch <- value`）。
接收：使用`<-`运算符从通道读取数据（如`value := <-ch`）。

示例：基础通道操作[编辑 | 编辑源代码]

package main

import "fmt"

func main() {
    ch := make(chan int) // 创建一个整型通道

    go func() {
        ch <- 42 // 发送数据到通道
    }()

    value := <-ch // 从通道接收数据
    fmt.Println("Received:", value) // 输出: Received: 42
}

通道类型[编辑 | 编辑源代码]

Go通道分为两类：

无缓冲通道：默认类型，发送和接收操作会阻塞，直到另一端准备好。
有缓冲通道：通过指定容量创建（如`make(chan int, 5)`），仅在缓冲区满时阻塞发送，空时阻塞接收。

缓冲通道示例[编辑 | 编辑源代码]

func main() {
    ch := make(chan string, 2) // 容量为2的缓冲通道

    ch <- "Hello"
    ch <- "World"

    fmt.Println(<-ch) // 输出: Hello
    fmt.Println(<-ch) // 输出: World
}

通道同步[编辑 | 编辑源代码]

通道的阻塞特性天然支持协程同步。以下示例演示如何等待协程完成：

func worker(done chan bool) {
    fmt.Println("Working...")
    done <- true // 发送完成信号
}

func main() {
    done := make(chan bool)
    go worker(done)
    <-done // 阻塞直到收到信号
    fmt.Println("Done")
}

高级特性[编辑 | 编辑源代码]

通道方向[编辑 | 编辑源代码]

函数参数可指定通道方向（只读或只写）以提高类型安全：

func ping(pings chan<- string, msg string) { // 只写通道
    pings <- msg
}

func pong(pings <-chan string, pongs chan<- string) { // 只读和只写通道
    msg := <-pings
    pongs <- msg
}

select语句[编辑 | 编辑源代码]

`select`允许协程同时等待多个通道操作：

func main() {
    ch1, ch2 := make(chan string), make(chan string)

    go func() { ch1 <- "from ch1" }()
    go func() { ch2 <- "from ch2" }()

    select {
    case msg1 := <-ch1:
        fmt.Println(msg1)
    case msg2 := <-ch2:
        fmt.Println(msg2)
    }
}

通道关闭[编辑 | 编辑源代码]

通过`close(ch)`关闭通道，接收方可使用`val, ok := <-ch`检测通道状态：

func main() {
    ch := make(chan int)
    go func() {
        for i := 0; i < 3; i++ {
            ch <- i
        }
        close(ch)
    }()

    for {
        if val, ok := <-ch; ok {
            fmt.Println(val)
        } else {
            break
        }
    }
}

实际应用案例[编辑 | 编辑源代码]

生产者-消费者模型[编辑 | 编辑源代码]

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

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

func main() {
    ch := make(chan int)
    go producer(ch)
    consumer(ch)
}

工作池（Worker Pool）[编辑 | 编辑源代码]

利用缓冲通道实现并发任务分发：

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, j)
        results <- j * 2
    }
}

func main() {
    jobs, results := make(chan int, 10), make(chan int, 10)

    // 启动3个worker
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // 分发9个任务
    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    // 收集结果
    for a := 1; a <= 9; a++ {
        <-results
    }
}