用Java实现滑动窗口协议的模拟

以下是用Java实现滑动窗口协议的示例代码：

import java.io.*;
import java.net.*;
import java.util.*;

public class SlidingWindowProtocol {

    private static final int WINDOW_SIZE = 4;  // 窗口大小
    private static final int TIMEOUT = 1000;   // 超时时间

    public static void main(String[] args) throws Exception {
        // 创建服务器套接字
        ServerSocket serverSocket = new ServerSocket(8000);

        // 等待客户端连接
        System.out.println("等待客户端连接...");
        Socket clientSocket = serverSocket.accept();
        System.out.println("客户端已连接");

        // 创建输入输出流
        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

        // 读取数据包总数
        int totalPackets = Integer.parseInt(in.readLine());
        System.out.println("数据包总数：" + totalPackets);

        // 创建滑动窗口
        int base = 0;
        int nextSeqNum = 0;
        boolean[] acks = new boolean[totalPackets];
        List<String> packets = new ArrayList<>();
        for (int i = 0; i < totalPackets; i++) {
            packets.add(in.readLine());
        }

        // 发送窗口内的数据包
        while (base < totalPackets) {
            // 发送窗口内未被确认的数据包
            for (int i = base; i < Math.min(base + WINDOW_SIZE, totalPackets); i++) {
                if (!acks[i]) {
                    out.println(i + "," + packets.get(i));
                    System.out.println("发送数据包：" + i);
                }
            }

            // 等待ACK
            Timer timer = new Timer(true);
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    // 超时，重传窗口内未被确认的数据包
                    for (int i = base; i < Math.min(base + WINDOW_SIZE, totalPackets); i++) {
                        if (!acks[i]) {
                            out.println(i + "," + packets.get(i));
                            System.out.println("重传数据包：" + i);
                        }
                    }
                }
            }, TIMEOUT);

            // 接收ACK
            while (true) {
                String ack = in.readLine();
                int ackNum = Integer.parseInt(ack);
                System.out.println("接收ACK：" + ackNum);
                if (ackNum < base || ackNum >= base + WINDOW_SIZE) {
                    // ACK不在窗口内，丢弃
                    continue;
                }
                acks[ackNum] = true;
                if (ackNum == base) {
                    // 收到窗口内第一个未被确认的ACK，滑动窗口
                    timer.cancel();
                    base++;
                    break;
                }
            }
        }

        // 发送结束标记
        out.println("-1");
        System.out.println("发送结束标记");

        // 关闭输入输出流和套接字
        in.close();
        out.close();
        clientSocket.close();
        serverSocket.close();
    }
}

在以上示例代码中，我们模拟了一个简单的滑动窗口协议，用于在客户端和服务器之间传输数据包。服务器使用`ServerSocket`类监听8000端口，并等待客户端连接。一旦客户端连接成功，服务器就可以开始传输数据包。

服务器首先读取数据包总数，然后创建一个滑动窗口，窗口大小为4。服务器将所有数据包保存在一个列表中，然后开始发送窗口内未被确认的数据包。服务器使用`Timer`类创建一个定时器，设置超时时间为1秒。一旦超时，服务器将重传窗口内未被确认的数据包。

服务器同时等待ACK。一旦接收到ACK，服务器就将该ACK标记为已确认，并检查它是否是窗口内第一个未被确认的ACK。如果是，服务器就停止定时器，并滑动窗口。服务器重复以上过程，直到所有数据包都被确认。

在以上示例代码中，我们使用了`java.util.Timer`类实现定时器功能，并使用`java.util.TimerTask`类实现定时任务。在实际应用中，我们可能需要使用更高级别的定时器库，如Netty的`HashedWheelTimer`。