如何有效地关闭两个goroutines？

Question

I'm using two concurrent goroutines to copy stdin/stdout from my terminal to a net.Conn target. For some reason, I can't manage to completely stop the two go routines without getting a panic error (for trying to close a closed connection). This is my code:

func interact(c net.Conn, sessionMap map[int]net.Conn) {
    quit := make(chan bool) //the channel to quit

    copy := func(r io.ReadCloser, w io.WriteCloser) {
        defer func() {
            r.Close()
            w.Close()
            close(quit) //this is how i'm trying to close it
        }()

        _, err := io.Copy(w, r)

        if err != nil {
            //
        }

    }

    go func() {
        for {
            select {
            case <-quit:
                return
            default:
                copy(c, os.Stdout)
            }
        }
    }()

    go func() {
        for {
            select {
            case <-quit:
                return
            default:
                copy(os.Stdin, c)
            }
        }
    }()
}

This errors as panic: close of closed channel I want to terminate the two go routines, and then normally proceed to another function. What am I doing wrong?

Answer 1

You can't call close on a channel more than once, there's no reason to call copy in a for loop, since it can only operate one time, and you're copying in the wrong direction, writing to stdin and reading from stdout.

Simply asking how to quit 2 goroutines is simple, but that's not the only thing you need to do here. Since io.Copy is blocking, you don't need the extra synchronization to determine when the call is complete. This lets you simplify the code significantly, which will make it a lot easier to reason about.

func interact(c net.Conn) {
    go func() {
        // You want to close this outside the goroutine if you
        // expect to send data back over a half-closed connection
        defer c.Close()

        // Optionally close stdout here if you need to signal the
        // end of the stream in a pipeline.
        defer os.Stdout.Close()

        _, err := io.Copy(os.Stdout, c)
        if err != nil {
            //
        }
    }()

    _, err := io.Copy(c, os.Stdin)
    if err != nil {
        //
    }
}

Also note that you may not be able to break out of the io.Copy from stdin, so you can't expect the interact function to return. Manually doing the io.Copy in the function body and checking for a half-closed connection on every loop may be a good idea, then you can break out sooner and ensure that you fully close the net.Conn.