golang TCPConn.SetWriteDeadline似乎没有按预期工作

事情就是这样：

>服务器启动
>客户连接
>服务器发送消息,客户端接收消息
>客户关闭
>服务器再发送一条消息：没有错误
>服务器发送第三条消息：现在只显示错误

问题：为什么只有第二条消息发送给不存在的客户端会导致错误？案件应如何妥善处理？

代码如下：

package main

import (
    "net"
    "os"
    "bufio"
    "fmt"
    "time"
)

func AcceptConnections(listener net.Listener,console <- chan string) {

    msg := ""

    for {

        conn,err := listener.Accept()

        if err != nil {
            panic(err)
        }

        fmt.Printf("client connectedn")

        for {

            if msg == "" {
                msg = <- console
                fmt.Printf("read from console: %s",msg)
            }

            err = conn.SetWriteDeadline(time.Now().Add(time.Second))

            if err != nil {
                fmt.Printf("SetWriteDeadline failed: %vn",err)
            }

            _,err = conn.Write([]byte(msg))

            if err != nil {
                // expecting an error after sending a message
                // to a non-existing client endpoint
                fmt.Printf("failed sending a message to network: %vn",err)
                break
            } else {
                fmt.Printf("msg sent: %s",msg)
                msg = ""
            }
        }
    }
}

func ReadConsole(network chan <- string) {

    console := bufio.NewReader(os.Stdin)

    for {

        line,err := console.ReadString('n')

        if err != nil {

            panic(err)

        } else {

            network <- line
        }
    }
}

func main() {

    listener,err := net.Listen("tcp","localhost:6666")

    if err != nil {
        panic(err)
    }

    println("listening on " + listener.Addr().String())

    consoleToNetwork := make(chan string)

    go AcceptConnections(listener,consoleToNetwork)

    ReadConsole(consoleToNetwork)
}

服务器控制台如下所示：

listening on 127.0.0.1:6666
client connected
hi there!
read from console: hi there!
msg sent: hi there!
this one should fail
read from console: this one should fail
msg sent: this one should fail
this one actually fails
read from console: this one actually fails
failed sending a message to network: write tcp 127.0.0.1:51194: broken pipe

客户端看起来像这样：

package main

import (
    "net"
    "os"
    "io"
    //"bufio"
    //"fmt"
)

func cp(dst io.Writer,src io.Reader,errc chan<- error) {

    // -reads from src and writes to dst
    // -blocks until EOF
    // -EOF is not an error
    _,err :=  io.Copy(dst,src)

    // push err to the channel when io.Copy returns
    errc <- err
}

func StartCommunication(conn net.Conn) {

    //create a channel for errors
    errc := make(chan error)

    //read connection and print to console
    go cp(os.Stdout,conn,errc)

    //read user input and write to connection
    go cp(conn,os.Stdin,errc)

    //wait until nil or an error arrives
    err := <- errc

    if err != nil {
        println("cp error: ",err.Error())
    }
}

func main() {

    servAddr := "localhost:6666"

    tcpAddr,err := net.ResolveTCPAddr("tcp",servAddr)

    if err != nil {
        println("ResolveTCPAddr failed:",err.Error())
        os.Exit(1)
    }

    conn,err := net.DialTCP("tcp",nil,tcpAddr)

    if err != nil {
        println("net.DialTCP failed:",err.Error())
        os.Exit(1)
    }

    defer conn.Close()

    StartCommunication(conn)

}

编辑：按照JimB的建议,我想出了一个有效的例子.消息不会再丢失,并在新连接中重新发送.我不太确定在不同的go例程之间使用共享变量(connWrap.IsFaulted)有多安全.

package main

import (
    "net"
    "os"
    "bufio"
    "fmt"
)

type Connection struct {
    IsFaulted bool
    Conn net.Conn
}

func StartWritingToNetwork(connWrap * Connection,errChannel chan <- error,msgStack chan string) {

    for {

        msg := <- msgStack

        if connWrap.IsFaulted {

            //put it back for another connection
            msgStack <- msg

            return
        }

        _,err := connWrap.Conn.Write([]byte(msg))

        if err != nil {

            fmt.Printf("failed sending a message to network: %vn",err)

            connWrap.IsFaulted = true

            msgStack <- msg

            errChannel <- err

            return

        } else {

            fmt.Printf("msg sent: %s",msg)
        }
    }
}

func StartReadingFromNetwork(connWrap * Connection,errChannel chan <- error){

    network := bufio.NewReader(connWrap.Conn)

    for (!connWrap.IsFaulted) {

        line,err := network.ReadString('n')

        if err != nil {

            fmt.Printf("failed reading from network: %vn",err)

            connWrap.IsFaulted = true

            errChannel <- err

        } else {

            fmt.Printf("%s",line)
        }
    }
}

func AcceptConnections(listener net.Listener,console chan string) {

    errChannel := make(chan error)

    for {

        conn,err := listener.Accept()

        if err != nil {
            panic(err)
        }

        fmt.Printf("client connectedn")

        connWrap := Connection{false,conn}

        go StartReadingFromNetwork(&connWrap,errChannel)

        go StartWritingToNetwork(&connWrap,errChannel,console)

        //block until an error occurs
        <- errChannel
    }
}

func ReadConsole(network chan <- string) {

    console := bufio.NewReader(os.Stdin)

    for {

        line,consoleToNetwork)

    ReadConsole(consoleToNetwork)
}