为什么Go在向封闭通道写入时会感到恐慌？
虽然可以使用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上运行"从关闭通道读取"
向一个可能关闭的通道写操作要复杂得多，因为如果你只是在通道关闭的情况下写操作，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上运行"写入关闭通道"
据我所知，没有一个更简单的习惯用法可以让你不慌不忙地写入一个可能关闭的通道，为什么不呢？读写之间这种不对称行为背后的原因是什么？