Go并发编程：安全关闭Channel的策略与实践

close(channel_name)

package main

import (
    "fmt"
    "time"
)

func producer(ch chan int) {
    for i := 0; i < 5; i++ {
        ch <- i // 发送数据
        time.Sleep(100 * time.Millisecond)
    }
    close(ch) // 生产完毕，关闭channel
    fmt.Println("Producer: Channel closed.")
}

func consumer(ch chan int) {
    fmt.Println("Consumer: Starting to receive...")
    for val := range ch { // 当channel关闭且无数据时，循环自动退出
        fmt.Printf("Consumer: Received %d\n", val)
    }
    fmt.Println("Consumer: Channel closed and all data received, exiting.")
}

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

    go producer(dataCh)
    go consumer(dataCh)

    // 等待goroutine完成
    time.Sleep(2 * time.Second)
    fmt.Println("Main: Program finished.")
}

Consumer: Starting to receive...
Consumer: Received 0
Consumer: Received 1
Consumer: Received 2
Consumer: Received 3
Consumer: Received 4
Producer: Channel closed.
Consumer: Channel closed and all data received, exiting.
Main: Program finished.

package main

import (
    "fmt"
    "time"
)

func producerWithExplicitClose(ch chan int) {
    for i := 0; i < 3; i++ {
        ch <- i
        time.Sleep(100 * time.Millisecond)
    }
    close(ch)
    fmt.Println("ProducerWithExplicitClose: Channel closed.")
}

func consumerWithOkCheck(ch chan int) {
    fmt.Println("ConsumerWithOkCheck: Starting to receive...")
    for {
        val, ok := <-ch // 接收数据并检查channel状态
        if !ok {
            fmt.Println("ConsumerWithOkCheck: Channel closed, no more data.")
            break // channel已关闭，退出循环
        }
        fmt.Printf("ConsumerWithOkCheck: Received %d\n", val)
    }
    fmt.Println("ConsumerWithOkCheck: Exiting.")
}

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

    go producerWithExplicitClose(dataCh)
    go consumerWithOkCheck(dataCh)

    time.Sleep(1 * time.Second)
    fmt.Println("Main: Program finished.")
}

ConsumerWithOkCheck: Starting to receive...
ConsumerWithOkCheck: Received 0
ConsumerWithOkCheck: Received 1
ConsumerWithOkCheck: Received 2
ProducerWithExplicitClose: Channel closed.
ConsumerWithOkCheck: Channel closed, no more data.
ConsumerWithOkCheck: Exiting.
Main: Program finished.

package main

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

// Producer 模拟一个生产者，在完成任务或遇到错误时关闭channel
func Producer(dataCh chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    defer close(dataCh) // 确保channel在Producer退出时关闭

    fmt.Println("Producer: Starting production...")
    for i := 0; i < 10; i++ {
        // 模拟数据生成或网络IO
        time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)

        // 模拟TCP连接断开或发生错误
        if i == 5 {
            fmt.Println("Producer: Simulating error/TCP connection dropped. Closing channel.")
            return // 发生错误，提前退出，defer会关闭channel
        }
        dataCh <- i
        fmt.Printf("Producer: Sent %d\n", i)
    }
    fmt.Println("Producer: All data sent successfully.")
}

// Consumer 模拟一个消费者，优雅地从channel接收数据并处理关闭信号
func Consumer(dataCh <-chan int, wg *sync.WaitGroup, id int) {
    defer wg.Done()
    fmt.Printf("Consumer %d: Starting to consume...\n", id)
    for {
        select {
        case data, ok := <-dataCh:
            if !ok {
                fmt.Printf("Consumer %d: Channel closed, no more data. Exiting.\n", id)
                return // Channel已关闭，退出
            }
            fmt.Printf("Consumer %d: Received %d\n", id, data)
            // 模拟数据处理
            time.Sleep(time.Duration(rand.Intn(50)) * time.Millisecond)
        }
    }
}

func main() {
    dataCh := make(chan int)
    var wg sync.WaitGroup

    // 启动生产者
    wg.Add(1)
    go Producer(dataCh, &wg)

    // 启动多个消费者
    for i := 1; i <= 2; i++ {
        wg.Add(1)
        go Consumer(dataCh, &wg, i)
    }

    wg.Wait() // 等待所有goroutine完成
    fmt.Println("Main: All goroutines finished, program exiting.")
}