Golang中如何解决指令卡死导致的无限循环问题

在WebSocket读取操作中处理阻塞问题，可以使用带超时的上下文或设置读取截止时间。以下是几种解决方案：

方案1：使用带超时的上下文（推荐）

for {
    select {
    case <-sign:
        return // 使用return而不是break
    default:
        // 创建带超时的上下文
        ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        
        // 使用通道接收读取结果
        msgChan := make(chan []byte)
        errChan := make(chan error)
        
        go func() {
            msg, err := c.ReadMessage(-1)
            if err != nil {
                errChan <- err
                return
            }
            msgChan <- msg
        }()
        
        select {
        case <-ctx.Done():
            cancel()
            continue // 超时后继续循环检查终止信号
        case msg := <-msgChan:
            cancel()
            go processMessage(msg)
        case err := <-errChan:
            cancel()
            // 处理错误
            continue
        }
    }
}

方案2：设置读取截止时间

// 在连接上设置读取截止时间
c.SetReadDeadline(time.Now().Add(5 * time.Second))

for {
    select {
    case <-sign:
        return
    default:
        msg, err := c.ReadMessage(-1)
        if err != nil {
            if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                // 重置截止时间并继续
                c.SetReadDeadline(time.Now().Add(5 * time.Second))
                continue
            }
            // 其他错误处理
            return
        }
        
        // 重置截止时间
        c.SetReadDeadline(time.Now().Add(5 * time.Second))
        go processMessage(msg)
    }
}

方案3：使用goroutine和select组合

done := make(chan struct{})
msgChan := make(chan []byte)
errChan := make(chan error)

// 启动读取goroutine
go func() {
    for {
        msg, err := c.ReadMessage(-1)
        if err != nil {
            errChan <- err
            return
        }
        msgChan <- msg
    }
}()

for {
    select {
    case <-sign:
        close(done)
        return
    case msg := <-msgChan:
        go processMessage(msg)
    case err := <-errChan:
        // 处理错误
        return
    }
}

方案4：使用net.Conn的SetReadDeadline（针对原始连接）

// 获取底层连接
conn := c.UnderlyingConn()
if conn != nil {
    conn.SetReadDeadline(time.Now().Add(5 * time.Second))
}

for {
    select {
    case <-sign:
        return
    default:
        msg, err := c.ReadMessage(-1)
        if err != nil {
            if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                // 检查终止信号
                select {
                case <-sign:
                    return
                default:
                    // 重置截止时间
                    conn.SetReadDeadline(time.Now().Add(5 * time.Second))
                    continue
                }
            }
            return
        }
        
        // 重置截止时间
        conn.SetReadDeadline(time.Now().Add(5 * time.Second))
        go processMessage(msg)
    }
}

关键点：

1. break只能跳出select，不能跳出for循环，应该使用return
2. 通过设置超时或截止时间来避免永久阻塞
3. 使用goroutine分离读取操作，通过通道进行通信
4. 每次读取后需要重置截止时间