Go语言中优雅地关闭通道：实现Goroutine的协作与终止

package main

import (
    "fmt"
    "time"
)

// dataSender 模拟一个向通道发送数据的Goroutine
func dataSender(ch chan int, done chan struct{}) {
    defer close(ch) // 在函数退出时关闭数据通道，通知接收方不再有数据
    fmt.Println("Sender: Starting to send data...")
    for i := 0; i < 5; i++ {
        select {
        case ch <- i: // 尝试向通道发送数据
            fmt.Printf("Sender: Sent %d\n", i)
            time.Sleep(100 * time.Millisecond)
        case <-done: // 收到停止信号
            fmt.Println("Sender: Received done signal, stopping sending.")
            return
        }
    }
    fmt.Println("Sender: All data sent, closing channel.")
}

// dataReceiver 模拟一个从通道接收数据的Goroutine
func dataReceiver(ch chan int) {
    fmt.Println("Receiver: Starting to receive data...")
    // for range 循环会在通道关闭且所有数据被读取后自动退出
    for val := range ch {
        fmt.Printf("Receiver: Received %d\n", val)
    }
    fmt.Println("Receiver: Channel closed and all data processed, exiting.")
}

func main() {
    dataCh := make(chan int)          // 数据通道
    doneCh := make(chan struct{})     // 用于通知发送方停止的控制通道

    go dataSender(dataCh, doneCh)
    go dataReceiver(dataCh)

    // 主Goroutine等待一段时间，然后发送停止信号
    time.Sleep(1 * time.Second)
    fmt.Println("Main: Sending stop signal to sender...")
    close(doneCh) // 关闭doneCh，通知dataSender停止发送并关闭dataCh

    // 等待所有Goroutine完成其任务
    time.Sleep(500 * time.Millisecond)
    fmt.Println("Main: Program finished.")
}

package main

import (
    "fmt"
    "time"
)

// dataSenderWithSignal 模拟一个向通道发送数据的Goroutine，并响应停止信号
func dataSenderWithSignal(ch chan int, stop chan struct{}) {
    defer close(ch) // 在函数退出时关闭数据通道
    fmt.Println("Sender (with ok): Starting to send data...")
    for i := 0; i < 5; i++ {
        select {
        case ch <- i:
            fmt.Printf("Sender (with ok): Sent %d\n", i)
            time.Sleep(100 * time.Millisecond)
        case <-stop:
            fmt.Println("Sender (with ok): Received stop signal, stopping sending.")
            return
        }
    }
    fmt.Println("Sender (with ok): All data sent, closing channel.")
}

// dataReceiverWithOk 模拟一个从通道接收数据的Goroutine，并检查通道状态
func dataReceiverWithOk(ch chan int) {
    fmt.Println("Receiver (with ok): Starting to receive data...")
    for {
        val, ok := <-ch // 接收值并检查通道状态
        if !ok {
            fmt.Println("Receiver (with ok): Channel closed, exiting.")
            break // 通道已关闭，退出循环
        }
        fmt.Printf("Receiver (with ok): Received %d\n", val)
    }
}

func main() {
    dataCh := make(chan int)      // 数据通道
    stopCh := make(chan struct{}) // 用于通知发送方停止的控制通道

    go dataSenderWithSignal(dataCh, stopCh)
    go dataReceiverWithOk(dataCh)

    // 主Goroutine等待一段时间，然后发送停止信号
    time.Sleep(1 * time.Second)
    fmt.Println("Main: Sending stop signal to sender (with ok)...")
    close(stopCh) // 通知dataSenderWithSignal停止发送并关闭dataCh

    // 等待所有Goroutine完成其任务
    time.Sleep(500 * time.Millisecond)
    fmt.Println("Main: Program finished.")
}