Java TCP套接字：数据传输缓慢

Question

我使用 ServerSocket 设置了服务器，并使用客户端计算机连接到它。 它们通过交换机直接联网，ping 时间<1ms。

现在，我尝试通过套接字的输出流将“大量”数据从客户端推送到服务器。 传输0.6Gb需要23分钟。 我可以通过 scp 在几秒钟内推送一个更大的文件。

知道我可能做错了什么吗？ 我基本上只是在套接字上循环并调用 writeInt 。 速度问题与数据来自哪里无关，即使我只是发送一个常量整数而不是从磁盘读取。

我尝试将两侧的发送和接收缓冲区设置为 4Mb，没有骰子。 我为读取器和写入器使用缓冲流，没有骰子。

我错过了什么吗？

编辑：代码

这是我制作套接字的地方

System.out.println("Connecting to " + hostname);

    serverAddr = InetAddress.getByName(hostname);

    // connect and wait for port assignment
    Socket initialSock = new Socket();
    initialSock.connect(new InetSocketAddress(serverAddr, LDAMaster.LDA_MASTER_PORT));
    int newPort = LDAHelper.readConnectionForwardPacket(new DataInputStream(initialSock.getInputStream()));
    initialSock.close();
    initialSock = null;

    System.out.println("Forwarded to " + newPort);

    // got my new port, connect to it
    sock = new Socket();
    sock.setReceiveBufferSize(RECEIVE_BUFFER_SIZE);
    sock.setSendBufferSize(SEND_BUFFER_SIZE);
    sock.connect(new InetSocketAddress(serverAddr, newPort));

    System.out.println("Connected to " + hostname + ":" + newPort + " with buffers snd=" + sock.getSendBufferSize() + " rcv=" + sock.getReceiveBufferSize());

    // get the MD5s
    try {
        byte[] dataMd5 = LDAHelper.md5File(dataFile),
               indexMd5 = LDAHelper.md5File(indexFile);

        long freeSpace = 90210; // ** TODO: actually set this **

        output = new DataOutputStream(new BufferedOutputStream(sock.getOutputStream()));
        input  = new DataInputStream(new BufferedInputStream(sock.getInputStream()));

这是我进行服务器端连接的地方：

    ServerSocket servSock = new ServerSocket();
    servSock.setSoTimeout(SO_TIMEOUT);
    servSock.setReuseAddress(true);
    servSock.bind(new InetSocketAddress(LDA_MASTER_PORT));

    int currPort = LDA_START_PORT;

    while (true) {
        try {
            Socket conn = servSock.accept();
            System.out.println("Got a connection.  Sending them to port " + currPort);
            clients.add(new MasterClientCommunicator(this, currPort));
            clients.get(clients.size()-1).start();

            Thread.sleep(500);

            LDAHelper.sendConnectionForwardPacket(new DataOutputStream(conn.getOutputStream()), currPort);

            currPort++;
        } catch (SocketTimeoutException e) {
            System.out.println("Done listening.  Dispatching instructions.");
            break;
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

好吧，这是我发送超过 ~0.6Gb 数据的地方。

public static void sendTermDeltaPacket(DataOutputStream out, TIntIntHashMap[] termDelta) throws IOException {
    long bytesTransferred = 0, numZeros = 0;

    long start = System.currentTimeMillis();

    out.write(PACKET_TERM_DELTA); // header     
    out.flush();
    for (int z=0; z < termDelta.length; z++) {
        out.writeInt(termDelta[z].size()); // # of elements for each term
        bytesTransferred += 4;
    }

    for (int z=0; z < termDelta.length; z++) {
        for (int i=0; i < termDelta[z].size(); i++) {
            out.writeInt(1);
            out.writeInt(1);
        }
    }

到目前为止似乎非常简单......

Answer 1

当您传输大量数据时，您不想写入单个字节。

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Transfer {

    public static void main(String[] args) {
        final String largeFile = "/home/dr/test.dat"; // REPLACE
        final int BUFFER_SIZE = 65536;
        new Thread(new Runnable() {
            public void run() {
                try {
                    ServerSocket serverSocket = new ServerSocket(12345);
                    Socket clientSocket = serverSocket.accept();
                    long startTime = System.currentTimeMillis();
                    byte[] buffer = new byte[BUFFER_SIZE];
                    int read;
                    int totalRead = 0;
                    InputStream clientInputStream = clientSocket.getInputStream();
                    while ((read = clientInputStream.read(buffer)) != -1) {
                        totalRead += read;
                    }
                    long endTime = System.currentTimeMillis();
                    System.out.println(totalRead + " bytes read in " + (endTime - startTime) + " ms.");
                } catch (IOException e) {
                }
            }
        }).start();
        new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(1000);
                    Socket socket = new Socket("localhost", 12345);
                    FileInputStream fileInputStream = new FileInputStream(largeFile);
                    OutputStream socketOutputStream = socket.getOutputStream();
                    long startTime = System.currentTimeMillis();
                    byte[] buffer = new byte[BUFFER_SIZE];
                    int read;
                    int readTotal = 0;
                    while ((read = fileInputStream.read(buffer)) != -1) {
                        socketOutputStream.write(buffer, 0, read);
                        readTotal += read;
                    }
                    socketOutputStream.close();
                    fileInputStream.close();
                    socket.close();
                    long endTime = System.currentTimeMillis();
                    System.out.println(readTotal + " bytes written in " + (endTime - startTime) + " ms.");
                } catch (Exception e) {
                }
            }
        }).start();
    }
}

这在我的机器上在短短 19 秒内复制了 1 GiB 的数据。 这里的关键是使用 InputStream.read 和

Answer 2

嘿，我想我会跟进任何感兴趣的人。

这是这个故事的奇怪寓意：

永远不要使用 DataInputStream/DataOutputStream 和套接字！！

如果我将套接字包装在 BufferedOutputStream/BufferedInputStream 中，生活就会很棒。 原始写入就可以了。

但是将套接字包装在 DataInputStream/DataOutputStream 中，甚至使用 DataOutputStream(BufferedOutputStream(sock.getOutputStream())) 速度非常慢。

对此的解释对我来说真的很有趣。 但是在交换所有内容之后，情况就是这样。 如果你不相信我，你自己试试。

不过，感谢您的快速帮助。

Answer 3

也许您应该尝试以块（帧）的形式发送数据，而不是单独写入每个字节。 并使帧与 TCP 数据包大小保持一致，以获得最佳性能。

Answer 4

您可以尝试通过环回执行此操作吗，然后它应该立即传输数据。

如果需要几分钟，则说明您的应用程序存在问题。 如果只是通过互联网发送数据很慢，则可能是您的网络链接速度很慢。

我的猜测是，您的客户端和服务器之间有一个 10 Mb/s 的网络，这就是您的传输速度缓慢的原因。 如果是这种情况，请尝试使用 DeflatoutOutputStream 和 InflatorInputStream 进行连接。

Answer 5

您如何实现接收端？ 请同时发布您的接收代码。

由于 TCP 是一种可靠的协议，因此它将采取措施确保客户端能够接收发送方发送的所有数据。 这意味着，如果您的客户端无法及时从数据接收缓冲区中获取数据，那么发送方将停止发送更多数据，直到客户端有机会读取接收缓冲区中的所有字节。

如果您的接收方一次读取一个字节的数据，那么您的发送方可能会花费大量时间等待接收缓冲区清除，因此传输时间较长。 我建议更改您的接收代码以在每次读取操作中读取尽可能多的字节。 看看这是否能解决您的问题。

Answer 6

由于我还无法对此网站发表评论，因此我必须在这里写下对@Erik 的回答。

问题是 DataOutputStream 不缓冲。 Java 中的整个 Stream-thing 是基于装饰器设计模式的。 所以你可以写

DataOutputStream out = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));

它将把原始流包装在一个更高效的 BufferedOutputStream 中，然后将其包装到一个 DataOutputStream 中提供了额外的好功能，如 writeInt()、writeLong() 等。

Answer 7

@Erik：使用 DataXxxputStream 不是这里的问题。 问题是您发送的数据块太小。 使用缓冲区解决了您的问题，因为即使您一点一点地写入缓冲区也可以解决问题。
Bombe 的解决方案更好、通用且更快。

Answer 8

我正在使用 PrintWriter 发送数据。 我删除了它并使用 BufferedOutputStream.send(String.getBytes()) 发送数据，并且发送速度提高了大约 10 倍。

Answer 9

您应该下载一个好的数据包嗅探器。 我个人是 WireShark 的忠实粉丝，每次进行套接字编程时我都会使用它。 请记住，您必须让客户端和服务器在不同的系统上运行才能接收任何数据包。

Answer 10

你的堆大小是如何设置的？ 我最近在大量数据的套接字传输方面遇到了类似的问题，仅通过查看 JConsole，我就意识到应用程序将大部分时间都花在了完整的 GC 上。

尝试-Xmx1g

Answer 11

要尝试的事情：

• 发送数据时 CPU 是否处于 100%？ 如果是这样，请使用 VisualVM 并进行 CPU 分析以查看时间花在哪里
• 使用 java.nio 中的 SocketChannel - 这些通常更快，因为它们可以更轻松地使用本机 IO - 当然这仅在您的操作受 CPU 限制时才有帮助
• 如果它不受 CPU 限制，而是网络级别出了问题。 使用数据包嗅探器来分析这一点。

Answer 12

使用字节缓冲区发送数据