为什么我的 TCP 系统比 UDP 系统快？

Question

我有两个（客户端-服务器-客户端）系统。第一个使用 TCP，第二个使用 UDP。有趣的是，在传输大小为 5-6 mb 的文件时，我的 TCP 使用系统比使用 UDP 的系统更快。问题是因为我的编码错误还是会发生？

TCP 客户端

   try {
       socket = new Socket("localhost", 7755);
   } catch (Exception e) {
       System.out.println(e.getMessage().toString());
   }

   out = new PrintWriter(socket.getOutputStream(), true);

   int i = 0;

   while (file.hasNext()) {
       String line = file.nextLine();
       if (!line.isEmpty()) {
           out.println(line);
       }
       i++;
   }

TCP 服务器

     try {
          serverSocketA = new ServerSocket(7755);
          serverSocketB = new ServerSocket(7760);
     } catch (Exception e) {
          System.out.println("Port error!");
     }
     System.out.println("Server is ready...");
     clientSocketA = serverSocketA.accept();
     clientSocketB = serverSocketB.accept();

     PrintWriter out = new PrintWriter(clientSocketB.getOutputStream(), true);

     BufferedReader in = new BufferedReader(new InputStreamReader(clientSocketA.getInputStream()));

     while((dataFromClientA = in.readLine()) != null) {
          out.println(dataFromClientA);
     }

UDP 服务器

private static byte[] buf = new byte[6];
static Scanner file;

public static void main(String[] args) throws IOException{
    long startTime = System.currentTimeMillis();
    socket = new DatagramSocket();
    address = InetAddress.getByName("localhost");
    file = new Scanner(new File("sentfile.txt"));
    DatagramPacket packet;
    while (file.hasNext()) {
        String line = file.nextLine();
        if (!line.isEmpty()) {
            buf = line.getBytes();
            packet = new DatagramPacket(buf, buf.length, address, 7765);
            socket.send(packet);
        }
    }

UDP 客户端

private static byte[] buffer = new byte[6];
private static byte[] buffer2 = new byte[6];
private static boolean running;
static PrintWriter writer;

public static void main(String[] args) throws IOException {
    udpSocketB = new DatagramSocket();
    address = InetAddress.getByName("localhost");
    udpSocketA = new DatagramSocket(7765);
    running = true;
    DatagramPacket packet;
    while(running) {
        packet = new DatagramPacket(buffer, buffer.length);
        udpSocketA.receive(packet);
        InetAddress address = packet.getAddress();
        int port = packet.getPort();
        packet = new DatagramPacket(buffer, buffer.length, address, port);
        String received = new String(packet.getData(), 0, packet.getLength());
        DatagramPacket packetToB;
        buffer2 = received.getBytes();
        packetToB = new DatagramPacket(buffer2, buffer2.length, address, 7770);
        udpSocketB.send(packetToB);
        if (received.equals("end")) {
            running = false;
            continue;
        }
    }

我只是添加了客户端 1 和服务器代码，其余部分类似。可能是什么原因？

Answer 1

当您通过 TCP 套接字进行写入时，它会尽可能将字节合并成大约 1500 字节的 MTU 数据，从而使数据包标头的开销相对较小。

当您在自己的 UDP 数据包中写入每一行时，每行都会产生开销，可能超过实际发送的数据。

注意：在这两种情况下，您都不需要一次读取一行。您可以一次读取 1 KB 的 byte[] 并打印出来。

public class TCPClient {
    public static void main(String[] args) throws IOException {
        try (Socket socket = new Socket("localhost", 7755);
             FileInputStream fis = new FileInputStream(args[0])) {
            byte[] bytes = new byte[1024];
            OutputStream out = socket.getOutputStream();
            for (int len; (len = fis.read(bytes)) > 0; ) {
                out.write(bytes, 0, len);
            }
        }
    }
}

public class TCPServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(7755);
        System.out.println("Server is ready...");
        try (Socket socket = serverSocket.accept()) {
            byte[] bytes = new byte[1024];
            for (int len; (len = socket.getInputStream().read(bytes)) > 0; )
                System.out.write(bytes, 0, len);
        }
    }
}

您可以使用 UDP 做同样的事情，一次传输 1 KB 并获得相似的吞吐量。

注意：UDP 是有损的，因此您可能会丢失数据包，或者将它们弄乱。

Answer 2

世界上一些最伟大的网络专家已经对 TCP 进行了大量优化。它专为尽可能快速有效地通过 IP 网络发送数据流而设计。它与内核绑定，并且在大多数现代平台上作为一个单元进行了高度优化。你不会超越它，除非它做了一些你不需要的事情，并且你可以从不做那件事中获得显着的好处。