如何在出错时在内部干净地停止goroutines

Question

所有的，

func main() {

    l, err := net.Listen(CONN_TYPE, CONN_HOST+":"+ CONN_PORT)

    for {                                                                                                                                                                              
        // Listen for an incoming connection.                                                                                                                                   
        conn, err := l.Accept()                                                                                                                                                        
        if err != nil {
            fmt.Println("Error accepting: ", err.Error())                                                                                                                                  
            os.Exit(1)
        }

        done_flag := make(chan bool, 1)

        // Handle connections in a new goroutine.                                                                                                                                      
        go func() { 
            conn.Write([]byte("string1\n"))
            conn.Write([]byte("string2\n"))
            ...
        }()
    }
}

现在，我试图避免的是下面的连接语句代码，其中我将代码包装在goroutine中的错误处理中（类似于以下内容）：

    go func() {
        if (_err := _send_ack(conn, "string1\n"); _err != nil {
            done_flag <- true
        }
        if (_err := _send_ack(conn, "string2\n"); _err != nil {
            done_flag <- true
        }
    }()

相反，如果存在连接问题，我宁愿将整个过程短路，然后立即以错误退出goroutine，我也不愿意担心如何构造代码。我也许可以进一步包装_send_ack并将通道作为函数参数发送--但是如果程序是高度分层的，这就变得不确定了。例如，我可能有一个由几个函数组成的goroutine，每个函数处理不同的tcp会话--我不想在子程序中添加额外的通道参数，以便在调用堆栈中上下推进通道，以防我必须设置完成标志。此外，还有一个问题是，在设置done标志之后，goroutine会发生什么，以及如何在调用方中处理它。

如果我使用的是python或perl或C++，我会抛出一个异常，该异常附加了一个错误发生的堆栈跟踪，然后在调用方中处理该错误。但是由于golang没有异常，我希望有一种方法可以在不退出主程序的情况下停止goroutine cold--即：设置一个通道，使其出现相关错误，然后在该点停止执行。

我看到了恐慌功能，但我不确定这样做的副作用。您能在不影响主程序的情况下panic（）退出goroutine，或者有没有一种方法可以智能地短路goroutine，而不产生副作用，也许返回类似异常的东西，带有堆栈跟踪和错误？或者建议什么方法来干净地错误处理像这样的分层程序？

非常感谢你的帮助--我是golang的新手，这可能表明了。

艾德

Answer 1

golang建议使用显式错误而不是隐式异常。

// for code simplicity
func doSendACKImpl(conn net.Conn) error {
    if err := _send_ack(conn, "string1\n"); err != nil {
        return err
    }

    if err := _send_ack(conn, "string2\n"); err != nil {
        return err
    }

    return nil
}

func main() {
    l, err := net.Listen(CONN_TYPE, CONN_HOST+":"+ CONN_PORT)

    for {
        // Listen for an incoming connection.
        conn, err := l.Accept()
        if err != nil {
            fmt.Println("Error accepting: ", err.Error())
            os.Exit(1)
        }

        // can change to self defined ResponseType, here use error for demo
        workRes := make(chan error, 1)
        go func() {
            // return write back to channel
            workRes <- doSendACKImpl(conn)
        }()

        select {
        // read result back
        case resError := <-workRes:
            fmt.Printf("meet error %s", resError)
        }
    }
}

要获得更多的并发能力，请使用更大的通道缓冲区大小，并将处理结果处理程序移到另一个goroutine中

func main() {
    l, _ := net.Listen(CONN_TYPE, CONN_HOST+":"+CONN_PORT)

    // more result buffer size
    const workSize int = 100

    // can change to self defined ResponseType, here use error for demo
    workResBuffer := make(chan error, workSize)

    // goroutine collect result
    go func() {
        // get all result from worker responses
        for resError := range workResBuffer {
            fmt.Printf("meet error %s", resError)
        }
    }()

    for {
        // Listen for an incoming connection.
        conn, err := l.Accept()
        if err != nil {
            fmt.Println("Error accepting: ", err.Error())
            os.Exit(1)
        }

        // TODO: limit the goroutine number
        go func() {
            // return write back to channel
            workResBuffer <- doSendACKImpl(conn)
        }()
    }
}