不同的协议和场景防丢包方案

防丢包需要根据不同的协议和场景采用不同的策略。让我为你详细介绍各种防丢包方案：

一、TCP 层面的防丢包（自动处理）

TCP 本身已经内置了完善的防丢包机制：

1. TCP 自动重传机制

// TCP 自动处理丢包，开发者无需关心
class TCPConnection {
    func sendData(_ data: Data) {
        // TCP 底层自动处理：
        // ✅ 序列号：检测丢失和乱序
        // ✅ 确认机制：接收方确认收到
        // ✅ 超时重传：未确认的数据自动重发
        // ✅ 快速重传：收到3个重复ACK立即重传
        outputStream.write(data: data)
    }
}

2. TCP 参数优化

import Darwin

class OptimizedTCP {
    func optimizeSocket(_ socket: Int32) {
        // 1. 启用TCP_NODELAY（禁用Nagle算法）
        var noDelay: Int32 = 1
        setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, &noDelay, socklen_t(MemoryLayout<Int32>.size))
        
        // 2. 调整缓冲区大小
        var sendBufferSize = 1024 * 64  // 64KB
        var recvBufferSize = 1024 * 64
        setsockopt(socket, SOL_SOCKET, SO_SNDBUF, &sendBufferSize, socklen_t(MemoryLayout<Int32>.size))
        setsockopt(socket, SOL_SOCKET, SO_RCVBUF, &recvBufferSize, socklen_t(MemoryLayout<Int32>.size))
        
        // 3. 启用KeepAlive
        var keepAlive: Int32 = 1
        setsockopt(socket, SOL_SOCKET, SO_KEEPALIVE, &keepAlive, socklen_t(MemoryLayout<Int32>.size))
    }
}

二、UDP 层面的防丢包（需要手动实现）

UDP本身不保证可靠性，需要应用层实现防丢包：

1. 基础确认重传机制

class ReliableUDP {
    private var sequenceNumber: UInt32 = 0
    private var pendingPackets: [UInt32: (data: Data, timestamp: Date, retries: Int)] = [:]
    private let maxRetries = 3
    private let ackTimeout: TimeInterval = 1.0
    
    struct PacketHeader {
        let sequence: UInt32
        let totalParts: UInt16
        let partNumber: UInt16
        let checksum: UInt32
    }
    
    func sendReliableData(_ data: Data) {
        let sequence = sequenceNumber
        sequenceNumber += 1
        
        let packets = splitIntoPackets(data, sequence: sequence)
        
        for packet in packets {
            sendPacket(packet, sequence: sequence)
        }
    }
    
    private func sendPacket(_ packet: Data, sequence: UInt32) {
        pendingPackets[sequence] = (
            data: packet,
            timestamp: Date(),
            retries: 0
        )
        
        udpSend(packet)
        startAckTimer(for: sequence)
    }
    
    private func startAckTimer(for sequence: UInt32) {
        DispatchQueue.main.asyncAfter(deadline: .now() + ackTimeout) { [weak self] in
            guard let self = self,
                  var pending = self.pendingPackets[sequence],
                  Date().timeIntervalSince(pending.timestamp) >= self.ackTimeout else {
                return
            }
            
            if pending.retries < self.maxRetries {
                pending.retries += 1
                pending.timestamp = Date()
                self.pendingPackets[sequence] = pending
                
                print("🔁 重传序列 \(sequence)，尝试 \(pending.retries)/\(self.maxRetries)")
                self.udpSend(pending.data)
                self.startAckTimer(for: sequence)
            } else {
                print("❌ 序列 \(sequence) 重传失败")
                self.pendingPackets.removeValue(forKey: sequence)
                self.handlePacketLoss(sequence)
            }
        }
    }
    
    func receiveAck(_ sequence: UInt32) {
        if pendingPackets.removeValue(forKey: sequence) != nil {
            print("✅ 确认序列 \(sequence)")
        }
    }
}

2. 选择性重传（SACK）

class SelectiveRetransmissionUDP {
    private var receivedSequences = Set<UInt32>()
    
    func receivePacket(_ packet: Data) -> (needAck: Bool, missingSequences: [UInt32]) {
        let header = parseHeader(packet)
        
        // 记录已收到的序列号
        receivedSequences.insert(header.sequence)
        
        // 检查是否有缺失的包
        let missing = findMissingSequences()
        
        // 如果需要确认或报告缺失
        let needAck = shouldSendAck()
        
        return (needAck, missing)
    }
    
    private func findMissingSequences() -> [UInt32] {
        guard let maxSeq = receivedSequences.max() else { return [] }
        
        var missing: [UInt32] = []
        for seq in 0...maxSeq {
            if !receivedSequences.contains(seq) {
                missing.append(seq)
            }
        }
        return missing
    }
}

三、应用层防丢包策略

1. 消息确认机制

class MessageAckManager {
    private var pendingMessages: [String: (message: Any, timestamp: Date)] = [:]
    private let ackTimeout: TimeInterval = 5.0
    
    func sendMessageWithAck(_ message: ControlMessage, to device: String) {
        let messageId = UUID().uuidString
        let messageWithId = IdentifiedMessage(id: messageId, content: message)
        
        pendingMessages[messageId] = (message: message, timestamp: Date())
        
        // 发送消息
        sendToDevice(messageWithId, device: device)
        
        // 启动确认计时器
        startAckTimer(for: messageId)
    }
    
    func handleAck(_ messageId: String) {
        if pendingMessages.removeValue(forKey: messageId) != nil {
            print("✅ 消息 \(messageId) 确认收到")
        }
    }
    
    private func startAckTimer(for messageId: String) {
        DispatchQueue.main.asyncAfter(deadline: .now() + ackTimeout) { [weak self] in
            guard let self = self,
                  let pending = self.pendingMessages[messageId] else {
                return
            }
            
            if Date().timeIntervalSince(pending.timestamp) >= self.ackTimeout {
                print("🔄 消息 \(messageId) 超时，重新发送")
                self.resendMessage(messageId)
            }
        }
    }
}

2. 数据分片和重组

class FragmentationManager {
    private var reassemblyBuffers: [UInt32: [Int: Data]] = [:]
    private let maxFragmentSize = 1024  // 1KB
    
    func splitAndSend(_ largeData: Data, sequence: UInt32) {
        let totalFragments = (largeData.count + maxFragmentSize - 1) / maxFragmentSize
        
        for fragmentIndex in 0..<totalFragments {
            let start = fragmentIndex * maxFragmentSize
            let end = min(start + maxFragmentSize, largeData.count)
            let fragment = largeData.subdata(in: start..<end)
            
            let fragmentHeader = FragmentHeader(
                sequence: sequence,
                totalFragments: UInt16(totalFragments),
                fragmentIndex: UInt16(fragmentIndex)
            )
            
            sendFragment(fragment, header: fragmentHeader)
        }
    }
    
    func receiveFragment(_ fragment: Data, header: FragmentHeader) -> Data? {
        let sequence = header.sequence
        
        // 初始化重组缓冲区
        if reassemblyBuffers[sequence] == nil {
            reassemblyBuffers[sequence] = [:]
        }
        
        // 存储分片
        reassemblyBuffers[sequence]?[Int(header.fragmentIndex)] = fragment
        
        // 检查是否收齐所有分片
        if let buffer = reassemblyBuffers[sequence],
           buffer.count == Int(header.totalFragments) {
            
            // 按顺序重组数据
            var reassembledData = Data()
            for i in 0..<Int(header.totalFragments) {
                if let fragmentData = buffer[i] {
                    reassembledData.append(fragmentData)
                }
            }
            
            reassemblyBuffers.removeValue(forKey: sequence)
            return reassembledData
        }
        
        return nil
    }
}

四、MQTT 的防丢包（QoS机制）

1. MQTT QoS 等级

class MQTTQualityOfService {
    func demonstrateQoSLevels() {
        let mqttClient = CocoaMQTT(clientID: "device123")
        
        // QoS 0: 最多一次（可能丢失）
        mqttClient.publish("sensors/temp", withString: "25", qos: .qos0)
        
        // QoS 1: 至少一次（可能重复）
        mqttClient.publish("commands/light", withString: "on", qos: .qos1)
        
        // QoS 2: 恰好一次（可靠）
        mqttClient.publish("config/update", withString: configJson, qos: .qos2)
    }
}

// QoS 1 实现示例
class QoS1Handler {
    private var pendingPubAck: [UInt16: (message: Data, timestamp: Date)] = [:]
    
    func publishWithQoS1(_ message: String, topic: String) -> UInt16 {
        let messageId = generateMessageId()
        let mqttMessage = CocoaMQTTMessage(topic: topic, string: message, qos: .qos1)
        mqttMessage.messageId = messageId
        
        // 存储等待确认
        pendingPubAck[messageId] = (
            message: message.data(using: .utf8)!,
            timestamp: Date()
        )
        
        mqttClient.publish(mqttMessage)
        startPubAckTimer(messageId: messageId)
        
        return messageId
    }
    
    func handlePubAck(_ messageId: UInt16) {
        if pendingPubAck.removeValue(forKey: messageId) != nil {
            print("✅ QoS1 消息 \(messageId) 确认")
        }
    }
}

五、WebSocket 的防丢包

1. 应用层心跳和重连

class ReliableWebSocket: WebSocketDelegate {
    private var heartbeatTimer: Timer?
    private var reconnectTimer: Timer?
    private var isConnected = false
    private let heartbeatInterval: TimeInterval = 30.0
    
    func setupHeartbeat() {
        heartbeatTimer = Timer.scheduledTimer(withTimeInterval: heartbeatInterval, repeats: true) { [weak self] _ in
            self?.sendHeartbeat()
        }
    }
    
    private func sendHeartbeat() {
        let heartbeatMessage = ["type": "heartbeat", "timestamp": Date().timeIntervalSince1970]
        if let data = try? JSONSerialization.data(withJSONObject: heartbeatMessage) {
            webSocket.write(data: data)
        }
    }
    
    func handleDisconnection() {
        isConnected = false
        scheduleReconnect()
    }
    
    private func scheduleReconnect() {
        reconnectTimer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: false) { [weak self] _ in
            self?.webSocket.connect()
        }
    }
}

2. 消息确认机制

class WebSocketAckManager {
    private var pendingAcks: [String: (message: Any, callback: (Bool) -> Void)] = [:]
    private let ackTimeout: TimeInterval = 10.0
    
    func sendMessageWithAck(_ message: [String: Any], completion: @escaping (Bool) -> Void) {
        let messageId = UUID().uuidString
        var messageWithId = message
        messageWithId["id"] = messageId
        messageWithId["needAck"] = true
        
        if let data = try? JSONSerialization.data(withJSONObject: messageWithId) {
            pendingAcks[messageId] = (message: message, callback: completion)
            webSocket.write(data: data)
            
            // 设置超时
            DispatchQueue.main.asyncAfter(deadline: .now() + ackTimeout) { [weak self] in
                if let callback = self?.pendingAcks[messageId]?.callback {
                    callback(false) // 超时失败
                    self?.pendingAcks.removeValue(forKey: messageId)
                }
            }
        }
    }
    
    func handleAck(_ messageId: String) {
        if let (_, callback) = pendingAcks.removeValue(forKey: messageId) {
            callback(true) // 成功确认
        }
    }
}

六、网络质量自适应策略

1. 动态调整策略

class AdaptiveTransmission {
    private var packetLossRate: Double = 0.0
    private var rtt: TimeInterval = 0.1 // 初始RTT
    private let samplingWindow = 100 // 采样窗口
    
    func updateNetworkMetrics(sent: Int, lost: Int, newRtt: TimeInterval) {
        // 更新丢包率
        packetLossRate = Double(lost) / Double(sent)
        
        // 更新RTT（指数加权移动平均）
        rtt = 0.875 * rtt + 0.125 * newRtt
        
        adjustTransmissionStrategy()
    }
    
    private func adjustTransmissionStrategy() {
        if packetLossRate > 0.1 {
            // 高丢包率：减少数据量，增加重试
            reduceDataRate()
            increaseRetryCount()
        } else if rtt > 1.0 {
            // 高延迟：使用压缩，减少交互次数
            enableCompression()
            batchMessages()
        } else {
            // 网络良好：正常传输
            useNormalStrategy()
        }
    }
    
    private func reduceDataRate() {
        // 降低发送频率，减少数据大小
        print("📉 网络质量差，降低传输速率")
    }
}

七、综合防丢包方案

混合策略管理器

class AntiPacketLossManager {
    private let networkMonitor = NetworkMonitor()
    private let retryManager = RetryManager()
    private let fragmentationManager = FragmentationManager()
    
    func sendDataReliably(_ data: Data, to destination: String) {
        let networkCondition = networkMonitor.currentCondition
        
        switch networkCondition {
        case .excellent:
            // 网络好：直接发送
            sendDirectly(data, to: destination)
            
        case .good:
            // 网络一般：添加确认机制
            sendWithAck(data, to: destination)
            
        case .poor where data.count > 1024:
            // 网络差且数据大：分片发送
            fragmentationManager.splitAndSend(data, to: destination)
            
        case .poor:
            // 网络差：增加重试次数
            sendWithRetry(data, to: destination, maxRetries: 5)
            
        case .unstable:
            // 网络不稳定：使用最可靠的方案
            sendWithFragmentationAndAck(data, to: destination)
        }
    }
    
    private func sendWithFragmentationAndAck(_ data: Data, to destination: String) {
        print("🛡️ 使用分片+确认机制发送数据")
        // 组合使用分片和确认机制
    }
}

总结

防丢包策略选择：

场景	推荐策略	具体措施
TCP通信	依赖TCP机制	调整缓冲区、启用KeepAlive
UDP通信	应用层实现	序列号、确认、重传、分片
MQTT	使用QoS	QoS1/QoS2、持久会话
WebSocket	应用层确认	心跳、消息ID、重连
大文件传输	分片传输	数据分片、选择性重传
实时数据	前向纠错	添加冗余数据

关键原则：

1. TCP优先：能用TCP就不要用UDP
2. 分层防护：传输层+应用层双重保障
3. 自适应：根据网络状况动态调整策略
4. 监控反馈：实时监控丢包率并调整参数

根据你的具体应用场景选择合适的防丢包组合策略。