Go http.Server 连接管理与自定义Listener实现

type Listener interface {
    Accept() (Conn, error)
    Close() error
    Addr() Addr
}

package main

import (
    "fmt"
    "log"
    "net"
    "net/http"
    "sync"
    "time"
)

// countedConn 包装 net.Conn，以便在连接关闭时通知 CountingListener
type countedConn struct {
    net.Conn
    listener *CountingListener
}

// Close 实现了 net.Conn 接口的 Close 方法，并在关闭时递减连接计数
func (c *countedConn) Close() error {
    err := c.Conn.Close()
    c.listener.decrement() // 通知 listener 减少计数
    return err
}

// CountingListener 包装 net.Listener，并提供连接计数功能
type CountingListener struct {
    net.Listener
    mu    sync.Mutex
    count int32 // 当前活跃连接数
    limit int32 // 最大允许的并发连接数，0表示无限制
}

// NewCountingListener 创建一个新的 CountingListener
func NewCountingListener(l net.Listener, limit int32) *CountingListener {
    return &CountingListener{
        Listener: l,
        limit:    limit,
    }
}

// Accept 实现了 net.Listener 接口的 Accept 方法
func (cl *CountingListener) Accept() (net.Conn, error) {
    // 检查是否达到连接限制
    if cl.limit > 0 {
        cl.mu.Lock()
        if cl.count >= cl.limit {
            cl.mu.Unlock()
            // 达到限制，等待或返回错误
            log.Printf("Connection limit reached (%d/%d). Rejecting new connection.", cl.count, cl.limit)
            time.Sleep(100 * time.Millisecond) // 模拟拒绝连接时的短暂等待
            return nil, fmt.Errorf("connection limit exceeded")
        }
        cl.count++
        cl.mu.Unlock()
    } else {
        // 如果没有限制，也需要锁定来递增计数
        cl.mu.Lock()
        cl.count++
        cl.mu.Unlock()
    }

    // 接受底层连接
    conn, err := cl.Listener.Accept()
    if err != nil {
        cl.decrement() // 如果接受失败，需要回滚计数
        return nil, err
    }

    log.Printf("Accepted new connection. Current active connections: %d", cl.GetCount())
    return &countedConn{Conn: conn, listener: cl}, nil
}

// GetCount 返回当前活跃的连接数
func (cl *CountingListener) GetCount() int32 {
    cl.mu.Lock()
    defer cl.mu.Unlock()
    return cl.count
}

// decrement 减少活跃连接计数
func (cl *CountingListener) decrement() {
    cl.mu.Lock()
    cl.count--
    log.Printf("Connection closed. Current active connections: %d", cl.count)
    cl.mu.Unlock()
}

func main() {
    // 创建一个普通的 TCP Listener
    stdListener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }
    defer stdListener.Close()

    // 使用 CountingListener 包装标准 Listener，设置最大并发连接数为 2
    countingListener := NewCountingListener(stdListener, 2)

    // 定义 HTTP 请求处理器
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Printf("Handling request from %s", r.RemoteAddr)
        time.Sleep(2 * time.Second) // 模拟长时间处理
        fmt.Fprintf(w, "Hello from Go HTTP Server! Active connections: %d", countingListener.GetCount())
    })

    log.Printf("Server starting on :8080 with max connections: %d", countingListener.limit)
    // 使用自定义的 Listener 启动 HTTP 服务器
    server := &http.Server{Handler: nil} // 使用默认的多路复用器
    if err := server.Serve(countingListener); err != nil {
        log.Fatalf("Server failed: %v", err)
    }
}