// ========== TCP三次握手底层详解 ==========

// 【第一步：服务器端准备监听】
// 操作系统内核创建监听套接字，进入LISTEN状态
// 内核为该套接字维护一个"未完成连接队列（SYN队列）"和"已完成连接队列（ACCEPT队列）"
ServerSocket serverSocket = new ServerSocket(8080);
// 底层：调用socket()系统调用创建套接字，调用bind()绑定端口，调用listen()开始监听
// 内核状态：TCP状态机进入LISTEN状态，等待SYN包

// 【第二步：客户端发起连接（第一次握手）】
Socket socket = new Socket("127.0.0.1", 8080);
// 底层操作序列：
// 1. 调用socket()创建套接字
// 2. 调用connect()发起连接（触发第一次握手）
// 3. 内核生成初始序列号ISN_c = 随机数（如100），状态变为SYN_SENT
// 4. 构造TCP报文段：
// - 源端口：随机分配（如54321）
// - 目的端口：8080
// - 序列号SEQ = ISN_c = 100
// - 确认号ACK = 0（还没有收到对方数据）
// - 标志位：SYN=1, ACK=0, FIN=0
// - 窗口大小：65535（告知对方我的接收缓冲区大小）
// - MSS（最大段长度）：1460字节（协商双方能接受的最大数据包大小）
// 5. 将TCP报文段封装成IP数据包，通过网卡发送
// 6. 客户端进入SYN_SENT状态，等待服务器的SYN+ACK响应

// 【第三步：服务器响应（第二次握手）】
Socket clientSocket = serverSocket.accept(); // 此时阻塞在第一次握手
// 服务器端内核收到SYN包后的处理：
// 1. 内核检查端口8080是否在监听状态（LISTEN）
// 2. 创建新的连接控制块（TCB），状态变为SYN_RECV
// 3. 将连接放入"未完成连接队列"（SYN队列）
// 4. 生成初始序列号ISN_s = 随机数（如200）
// 5. 构造SYN+ACK报文段：
// - 源端口：8080
// - 目的端口：54321（客户端的源端口）
// - 序列号SEQ = ISN_s = 200
// - 确认号ACK = ISN_c + 1 = 101（期望收到客户端的下一个序列号）
// - 标志位：SYN=1, ACK=1（同时确认收到了客户端的SYN）
// - 窗口大小：65535
// - MSS：1460字节
// 6. 发送SYN+ACK包给客户端
// 7. 服务器进入SYN_RECV状态，等待客户端的ACK确认

// 【第四步：客户端确认（第三次握手）】
// 客户端内核收到SYN+ACK后的处理：
// 1. 验证确认号ACK_num=101是否等于ISN_c+1（验证服务器收到了我的SYN）
// 2. 状态从SYN_SENT变为ESTABLISHED
// 3. 构造ACK报文段：
// - 序列号SEQ = ISN_c + 1 = 101（第一次握手后序列号+1）
// - 确认号ACK = ISN_s + 1 = 201（期望收到服务器的下一个序列号）
// - 标志位：SYN=0, ACK=1（不再是SYN，只是确认）
// 4. 发送ACK包给服务器
// 5. connect()系统调用返回，Socket对象创建成功

// 【第五步：服务器完成连接建立】
// 服务器内核收到ACK后的处理：
// 1. 验证确认号ACK_num=201是否等于ISN_s+1（验证客户端收到了我的SYN+ACK）
// 2. 状态从SYN_RECV变为ESTABLISHED
// 3. 将连接从"未完成连接队列"移到"已完成连接队列"（ACCEPT队列）
// 4. accept()系统调用返回，clientSocket对象创建成功
// 此时三次握手完成，双方都进入ESTABLISHED状态，可以开始数据传输

// ========== 关键机制深入理解 ==========
// 1. 序列号（Sequence Number）的作用：
// - 每个字节都有唯一序列号，用于确保数据有序、可靠传输
// - 第一次握手后，客户端发送的第一个数据字节的序列号是101（ISN_c+1）
// - 服务器发送的第一个数据字节的序列号是201（ISN_s+1）

// 2. 确认号（Acknowledgment Number）的含义：
// - ACK_num = 期望收到的下一个序列号 = 已收到的最大序列号 + 1
// - 服务器回复ACK=101，表示"我期望收到你序列号为101的字节"
// - 同时也隐含确认"我已经收到了序列号100及之前的所有数据"

// 3. 为什么SYN和FIN标志位会消耗一个序列号？
// - SYN和FIN虽然不携带数据，但会改变连接状态，需要被确认
// - 因此第一次握手后，客户端的序列号从100变为101
// - 这是TCP协议的设计，确保状态转换的可靠性

// 4. 操作系统内核的状态机管理：
// 客户端状态变化：CLOSED → SYN_SENT → ESTABLISHED
// 服务器状态变化：CLOSED → LISTEN → SYN_RECV → ESTABLISHED
// 使用 netstat -an | grep 8080 可以查看连接状态

// 5. 超时重传机制：
// - 如果客户端发送SYN后，在超时时间内（默认约3秒）没收到SYN+ACK
// - 客户端会重传SYN包，重传次数默认5次
// - 重传间隔采用指数退避：1s, 2s, 4s, 8s, 16s

// 此时连接已建立，可进行数据读写
InputStream in = clientSocket.getInputStream();
OutputStream out = clientSocket.getOutputStream();
out.write("Hello TCP".getBytes());
// 发送数据时，每个字节都会分配序列号，确保可靠传输

| 特性 | TCP | UDP | |------------|----------------------|----------------------| | 连接模式 | 面向连接（三次握手） | 无连接（直接发送） | | 可靠性 | 可靠（不丢不乱） | 不可靠（可能丢包） | | 传输效率 | 低（握手、重传开销） | 高（无额外开销） | | 延迟 | 高（毫秒级到百毫秒级）| 低（微秒级到毫秒级）| | 适用场景 | 文件、支付 | 直播、游戏、DNS |

# Linux组播配置（临时）
ip link show eth0 # 查看网卡是否支持组播（输出中"MULTICAST"表示支持）
sysctl -w net.ipv4.ip_forward=1 # 启用IP转发（跨局域网组播需开启）
route add -net 224.0.0.0 netmask 240.0.0.0 dev eth0 # 添加组播路由

# Java组播发送示例（向224.0.0.1:5000发送组播数据）
DatagramSocket socket = new DatagramSocket();
String message = "股票A: 100元";
byte[] data = message.getBytes();
DatagramPacket packet = new DatagramPacket(
    data, data.length,
    InetAddress.getByName("224.0.0.1"), 5000
);
socket.send(packet);

# Java组播接收示例（加入224.0.0.1:5000组播组，接收数据）
MulticastSocket socket = new MulticastSocket(5000);
socket.joinGroup(InetAddress.getByName("224.0.0.1")); // 加入组播组（关键步骤）
byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
socket.receive(packet); // 阻塞等待接收
String message = new String(packet.getData(), 0, packet.getLength());

// FEC编码：3个数据块生成1个冗余块（RS(4,3)）
import org.apache.commons.codec.binary.Hex;

public class FECUtil {
    // 异或运算生成冗余块
    public static byte[] generateRedundantBlock(byte[][] dataBlocks) {
        if (dataBlocks.length != 3) {
            throw new IllegalArgumentException("需传入3个数据块");
        }
        int blockLength = dataBlocks[0].length;
        byte[] redundant = new byte[blockLength];
        // 每个字节异或：冗余块[i] = 数据块1[i] ^ 数据块2[i] ^ 数据块3[i]
        for (int i = 0; i < blockLength; i++) {
            redundant[i] = (byte) (dataBlocks[0][i] ^ dataBlocks[1][i] ^ dataBlocks[2][i]);
        }
        return redundant;
    }

    // 恢复丢失的数据块（假设丢失1个，用另外2个数据块+冗余块恢复）
    public static byte[] recoverLostBlock(byte[][] availableBlocks) {
        int blockLength = availableBlocks[0].length;
        byte[] lost = new byte[blockLength];
        // 异或恢复：丢失块[i] = 可用块1[i] ^ 可用块2[i] ^ 冗余块[i]
        for (int i = 0; i < blockLength; i++) {
            lost[i] = availableBlocks[0][i];
            for (int j = 1; j < availableBlocks.length; j++) {
                lost[i] ^= availableBlocks[j][i];
            }
        }
        return lost;
    }
}

# 客户端升级请求
GET /ws/chat HTTP/1.1
Host: localhost:8080
Connection: Upgrade
Upgrade: websocket
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13

# 服务器响应（101切换协议）
HTTP/1.1 101 Switching Protocols
Connection: Upgrade
Upgrade: websocket
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

// AI生成的核心代码片段（简化） ServerSocket serverSocket = new ServerSocket(8080); ExecutorService threadPool = Executors.newFixedThreadPool(10); // 线程池 while (true) { Socket clientSocket = serverSocket.accept(); // 接收客户端连接 threadPool.submit(() -> { try (InputStream in = clientSocket.getInputStream(); OutputStream out = clientSocket.getOutputStream()) { // 读取客户端消息 byte[] buffer = new byte[1024]; int len = in.read(buffer); String msg = new String(buffer, 0, len); // 回复消息 out.write(("已收到：" + msg).getBytes()); } catch (IOException e) { System.err.println("通信异常：" + e.getMessage()); } }); }

# 查看连接数统计
ss -tan | grep ESTAB | wc -l
# 输出：从初始1000+增至6万+，且无下降趋势——典型的"TCP连接泄漏"

# 统计丢包率
tcpdump -i eth0 udp port 1935 -c 1000 | grep "length" | wc -l
# 1000个UDP推流包中，仅收到750-800个，丢包率20%左右