Go语言网络服务器优雅关闭：处理net.Listener.Accept错误

package main

import (
    "io"
    "log"
    "net"
    "time"
)

// EchoServer 结构体定义了一个简单的Echo服务器
type EchoServer struct {
    listen net.Listener
    done   chan bool
}

// respond 处理单个客户端连接，将接收到的数据原样写回
func (es *EchoServer) respond(remote *net.TCPConn) {
    defer remote.Close()
    _, err := io.Copy(remote, remote)
    if err != nil {
        log.Printf("Error handling connection: %s", err)
    }
}

// serve 循环监听传入连接
func (es *EchoServer) serve() {
    for {
        conn, err := es.listen.Accept()
        // FIXME: 期望在此处区分“use of closed network connection”错误
        // 但该错误不是net包导出的类型
        if err != nil {
            log.Printf("Accept failed: %v", err) // 正常关闭时会打印此日志
            break
        }
        go es.respond(conn.(*net.TCPConn))
    }
    es.done <- true // 通知stop方法serve协程已退出
}

// stop 通过关闭监听器来停止服务器
func (es *EchoServer) stop() {
    es.listen.Close() // 关闭监听器，导致Accept()返回错误
    <-es.done         // 等待serve协程退出
}

// NewEchoServer 创建并启动一个新的Echo服务器
func NewEchoServer(address string) *EchoServer {
    listen, err := net.Listen("tcp", address)
    if err != nil {
        log.Fatalf("Failed to open listening socket: %s", err)
    }
    es := &EchoServer{
        listen: listen,
        done:   make(chan bool), // 无缓冲通道
    }
    go es.serve()
    return es
}

func main() {
    log.Println("Starting echo server")
    es := NewEchoServer("127.0.0.1:18081")
    time.Sleep(1 * time.Second) // 运行服务器1秒
    log.Println("Stopping echo server")
    es.stop()
    log.Println("Server stopped")
}

2023/10/27 10:00:00 Starting echo server
2023/10/27 10:00:01 Stopping echo server
2023/10/27 10:00:01 Accept failed: accept tcp 127.0.0.1:18081: use of closed network connection
2023/10/27 10:00:01 Server stopped

package main

import (
    "io"
    "log"
    "net"
    "time"
)

// EchoServer 结构体定义了一个简单的Echo服务器
type EchoServer struct {
    listen net.Listener
    done   chan bool // 修改为带缓冲通道
}

// respond 处理单个客户端连接，将接收到的数据原样写回
func (es *EchoServer) respond(remote *net.TCPConn) {
    defer remote.Close()
    _, err := io.Copy(remote, remote)
    if err != nil {
        log.Printf("Error handling connection: %s", err)
    }
}

// serve 循环监听传入连接
func (es *EchoServer) serve() {
    for {
        conn, err := es.listen.Accept()
        if err != nil {
            select {
            case <-es.done:
                // 如果能从es.done读取到值，说明stop()已发送关闭信号，
                // 此时的Accept错误是预期的“use of closed network connection”，
                // 无需打印日志，直接退出。
                log.Println("Server listener closed gracefully.")
            default:
                // 否则，是其他非预期的Accept错误，需要打印日志。
                log.Printf("Accept failed unexpectedly: %v", err)
            }
            return // 退出serve循环
        }
        go es.respond(conn.(*net.TCPConn))
    }
}

// stop 通过关闭监听器来停止服务器
func (es *EchoServer) stop() {
    es.done <- true      // 1. 先向es.done发送信号，由于是缓冲通道，此处不会阻塞
    es.listen.Close()    // 2. 关闭监听器，导致Accept()返回错误
    // 注意：此处不再需要等待es.done，因为serve协程会在收到信号并处理完Accept错误后自行退出
}

// NewEchoServer 创建并启动一个新的Echo服务器
func NewEchoServer(address string) *EchoServer {
    listen, err := net.Listen("tcp", address)
    if err != nil {
        log.Fatalf("Failed to open listening socket: %s", err)
    }
    es := &EchoServer{
        listen: listen,
        done:   make(chan bool, 1), // 创建一个容量为1的缓冲通道
    }
    go es.serve()
    return es
}

func main() {
    log.Println("Starting echo server")
    es := NewEchoServer("127.0.0.1:18081")
    time.Sleep(1 * time.Second) // 运行服务器1秒
    log.Println("Stopping echo server")
    es.stop()
    // 在main goroutine中等待一段时间，确保serve goroutine有时间退出
    // 实际应用中可能需要更健壮的等待机制，例如使用sync.WaitGroup
    time.Sleep(100 * time.Millisecond)
    log.Println("Server stopped")
}

2023/10/27 10:00:00 Starting echo server
2023/10/27 10:00:01 Stopping echo server
2023/10/27 10:00:01 Server listener closed gracefully.
2023/10/27 10:00:01 Server stopped