Golang中如何轮询连接

在Go语言中，要确认TLS连接是否仍然有效并设置超时阈值，可以通过以下几种方式实现：

1. 使用SetDeadline方法轮询连接状态

package main

import (
    "crypto/tls"
    "fmt"
    "net"
    "time"
)

func checkConnection(conn *tls.Conn) bool {
    // 设置读取超时为1秒
    conn.SetReadDeadline(time.Now().Add(1 * time.Second))
    
    // 尝试读取一个字节来检测连接状态
    oneByte := make([]byte, 1)
    _, err := conn.Read(oneByte)
    
    if err != nil {
        if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
            // 超时错误表示连接仍然活跃
            return true
        }
        // 其他错误表示连接已断开
        return false
    }
    
    return true
}

func main() {
    conn, err := tls.Dial("tcp", "192.168.1.10:443", &tls.Config{
        InsecureSkipVerify: true, // 仅用于测试
    })
    if err != nil {
        fmt.Println("连接失败:", err)
        return
    }
    defer conn.Close()
    
    fmt.Println("Connected")
    
    // 定期检查连接状态
    ticker := time.NewTicker(30 * time.Second)
    defer ticker.Stop()
    
    for range ticker.C {
        if !checkConnection(conn) {
            fmt.Println("连接已断开")
            conn.Close()
            break
        }
        fmt.Println("连接正常")
    }
}

2. 使用Ping-Pong机制（如果服务器支持）

package main

import (
    "crypto/tls"
    "fmt"
    "io"
    "time"
)

func pingConnection(conn *tls.Conn) bool {
    // 发送ping消息（根据实际协议调整）
    _, err := conn.Write([]byte("ping"))
    if err != nil {
        return false
    }
    
    // 设置读取超时
    conn.SetReadDeadline(time.Now().Add(5 * time.Second))
    
    // 读取响应
    buffer := make([]byte, 4)
    _, err = conn.Read(buffer)
    if err != nil {
        if err == io.EOF {
            return false
        }
        return false
    }
    
    return string(buffer) == "pong"
}

func main() {
    conn, err := tls.Dial("tcp", "192.168.1.10:443", &tls.Config{
        InsecureSkipVerify: true,
    })
    if err != nil {
        fmt.Println("连接失败:", err)
        return
    }
    defer conn.Close()
    
    fmt.Println("Connected")
    
    // 定期ping检查
    for {
        time.Sleep(30 * time.Second)
        
        if !pingConnection(conn) {
            fmt.Println("连接失败，关闭连接")
            conn.Close()
            break
        }
        fmt.Println("连接活跃")
    }
}

3. 使用context.WithTimeout进行带超时的操作

package main

import (
    "context"
    "crypto/tls"
    "fmt"
    "time"
)

func isConnectionAlive(conn *tls.Conn) bool {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    done := make(chan bool, 1)
    
    go func() {
        // 尝试进行一个空操作来检测连接
        conn.SetReadDeadline(time.Now().Add(1 * time.Second))
        oneByte := make([]byte, 1)
        _, err := conn.Read(oneByte)
        
        if err != nil {
            // 检查是否为超时错误（连接正常）或其他错误（连接断开）
            if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                done <- true
                return
            }
            done <- false
            return
        }
        done <- true
    }()
    
    select {
    case result := <-done:
        return result
    case <-ctx.Done():
        return false
    }
}

func main() {
    conn, err := tls.Dial("tcp", "192.168.1.10:443", &tls.Config{
        InsecureSkipVerify: true,
    })
    if err != nil {
        fmt.Println("连接失败:", err)
        return
    }
    defer conn.Close()
    
    fmt.Println("Connected")
    
    // 条件判断连接状态
    if !isConnectionAlive(conn) {
        fmt.Println("连接已失效，正在关闭")
        conn.Close()
        return
    }
    
    fmt.Println("连接正常，继续执行")
}

4. 完整的连接管理示例

package main

import (
    "crypto/tls"
    "fmt"
    "net"
    "time"
)

type ConnectionManager struct {
    conn        *tls.Conn
    checkInterval time.Duration
    timeout      time.Duration
}

func NewConnectionManager(addr string, checkInterval, timeout time.Duration) (*ConnectionManager, error) {
    conn, err := tls.Dial("tcp", addr, &tls.Config{
        InsecureSkipVerify: true,
    })
    if err != nil {
        return nil, err
    }
    
    return &ConnectionManager{
        conn:          conn,
        checkInterval: checkInterval,
        timeout:       timeout,
    }, nil
}

func (cm *ConnectionManager) IsAlive() bool {
    cm.conn.SetReadDeadline(time.Now().Add(cm.timeout))
    oneByte := make([]byte, 1)
    _, err := cm.conn.Read(oneByte)
    
    if err != nil {
        if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
            return true
        }
        return false
    }
    return true
}

func (cm *ConnectionManager) StartMonitoring() {
    ticker := time.NewTicker(cm.checkInterval)
    defer ticker.Stop()
    
    for range ticker.C {
        if !cm.IsAlive() {
            fmt.Println("连接失效，关闭连接")
            cm.conn.Close()
            break
        }
        fmt.Println("连接状态: 活跃")
    }
}

func main() {
    cm, err := NewConnectionManager("192.168.1.10:443", 30*time.Second, 1*time.Second)
    if err != nil {
        fmt.Println("创建连接失败:", err)
        return
    }
    defer cm.conn.Close()
    
    fmt.Println("Connected")
    cm.StartMonitoring()
}

这些方法通过设置超时和尝试读取操作来检测TLS连接的状态。第一种方法使用SetReadDeadline是最常用的方式，它能够在不实际断开连接的情况下检测连接是否仍然活跃。