为什么 Go 在写入封闭通道时会感到panic

为什么在写入关闭的通道时会出现panic ？

虽然人们可以使用value, ok := <-channel个习语从通道中读取，因此可以测试ok结果是否符合闭合通道:

// reading from closed channel

package main

import "fmt"

func main() {
    ch := make(chan int, 1)
    ch <- 2
    close(ch)

    read(ch)
    read(ch)
    read(ch)
}

func read(ch <-chan int) {
    i,ok := <- ch   
    if !ok {
        fmt.Printf("channel is closed\n")
        return
    }
    fmt.Printf("read %d from channel\n", i)
}

输出:

read 2 from channel
channel is closed
channel is closed

在Playground上运行"从关闭的通道读取"

向一个可能关闭的通道写入数据更复杂，因为如果在通道关闭时try 写入数据，Go会惊慌失措:

//writing to closed channel

package main

import (
    "fmt"
)

func main() {
    output := make(chan int, 1) // create channel
    write(output, 2)
    close(output) // close channel
    write(output, 3)
    write(output, 4)
}

// how to write on possibly closed channel
func write(out chan int, i int) (err error) {

    defer func() {
        // recover from panic caused by writing to a closed channel
        if r := recover(); r != nil {
            err = fmt.Errorf("%v", r)
            fmt.Printf("write: error writing %d on channel: %v\n", i, err)
            return
        }

        fmt.Printf("write: wrote %d on channel\n", i)
    }()

    out <- i // write on possibly closed channel

    return err
}

输出:

write: wrote 2 on channel
write: error writing 3 on channel: send on closed channel
write: error writing 4 on channel: send on closed channel

在Playground上运行"Write to Closed Channel"(写入关闭的通道

据我所知，没有一个更简单的习语可以让你在一个可能封闭的渠道中写作而不惊慌失措.为什么不呢？这种读写不对称行为背后的原因是什么？