网络编程中Nagle算法和Delayed ACK的测试

     Nagle算法的立意是良好的，避免网络中充塞小封包，提高网络的利用率。但是当Nagle算法遇到delayed ACK悲剧就发生了。Delayed ACK的本意也是为了提高TCP性能，跟应答数据捎带上ACK，同时避免糊涂窗口综合症，也可以一个ack确认多个段来节省开销。
    悲剧发生在这种情况，假设一端发送数据并等待另一端应答，协议上分为头部和数据，发送的时候不幸地选择了write-write，然后再read，也就是先发送头部，再发送数据，最后等待应答。发送端的伪代码是这样

write(head);
write(body);
read(response);

 

接收端的处理代码类似这样：

read(request);
process(request);
write(response);

 

   这里假设head和body都比较小，当默认启用nagle算法，并且是第一次发送的时候，根据nagle算法，第一个段head可以立即发送，因为没有 等待确认的段；接收端收到head，但是包不完整，继续等待body达到并延迟ACK；发送端继续写入body，这时候nagle算法起作用了，因为 head还没有被ACK，所以body要延迟发送。这就造成了发送端和接收端都在等待对方发送数据的现象，发送端等待接收端ACK head以便继续发送body，而接收端在等待发送方发送body并延迟ACK，悲剧的无以言语。这种时候只有等待一端超时并发送数据才能继续往下走。

   正因为nagle算法和delayed ack的影响，再加上这种write-write-read的编程方式造成了很多网贴在讨论为什么自己写的网络程序性能那么差。然后很多人会在帖子里建议 禁用Nagle算法吧，设置TCP_NODELAY为true即可禁用nagle算法。但是这真的是解决问题的唯一办法和最好办法吗？

   其实问题不是出在nagle算法身上的，问题是出在write-write-read这种应用编程上。禁用nagle算法可以暂时解决问题，但是禁用 nagle算法也带来很大坏处，网络中充塞着小封包，网络的利用率上不去，在极端情况下，大量小封包导致网络拥塞甚至崩溃。因此，能不禁止还是不禁止的 好，后面我们会说下什么情况下才需要禁用nagle算法。对大多数应用来说，一般都是连续的请求——应答模型，有请求同时有应答，那么请求包的ACK其实 可以延迟到跟响应一起发送，在这种情况下，其实你只要避免write-write-read形式的调用就可以避免延迟现象，利用writev做聚集写或者 将head和body一起写，然后再read，变成write-read-write-read的形式来调用，就无需禁用nagle算法也可以做到不延 迟。

   writev是系统调用，在Java里是用到GatheringByteChannel.write(ByteBuffer[] srcs, int offset, int length)方法来做聚集写。这里可能还有一点值的提下，很多同学看java nio框架几乎都不用这个writev调用，这是有原因的。主要是因为Java的write本身对ByteBuffer有做临时缓存，而writev没有 做缓存，导致测试来看write反而比writev更高效，因此通常会更推荐用户将head和body放到同一个Buffer里来避免调用writev。

   下面我们将做个实际的代码测试来结束讨论。这个例子很简单，客户端发送一行数据到服务器，服务器简单地将这行数据返回。客户端发送的时候可以选择分两次 发，还是一次发送。分两次发就是write-write-read，一次发就是write-read-write-read，可以看看两种形式下延迟的差 异。注意，在windows上测试下面的代码，客户端和服务器必须分在两台机器上，似乎winsock对loopback连接的处理不一样。

    服务器源码：

package net.fnil.nagle;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;


public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket();
        serverSocket.bind(new InetSocketAddress(8000));
        System.out.println("Server startup at 8000");
        for (;;) {
            Socket socket = serverSocket.accept();
            InputStream in = socket.getInputStream();
            OutputStream out = socket.getOutputStream();

            while (true) {
                try {
                    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                    String line = reader.readLine();
                    out.write((line + "\r\n").getBytes());
                }
                catch (Exception e) {
                    break;
                }
            }
        }
    }
}

 

服务端绑定到本地8000端口，并监听连接，连上来的时候就阻塞读取一行数据，并将数据返回给客户端。

客户端代码：

package net.fnil.nagle;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;


public class Client {

    public static void main(String[] args) throws Exception {
        // 是否分开写head和body
        boolean writeSplit = false;
        String host = "localhost";
        if (args.length >= 1) {
            host = args[0];
        }
        if (args.length >= 2) {
            writeSplit = Boolean.valueOf(args[1]);
        }

        System.out.println("WriteSplit:" + writeSplit);

        Socket socket = new Socket();

        socket.connect(new InetSocketAddress(host, 8000));
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();

        BufferedReader reader = new BufferedReader(new InputStreamReader(in));

        String head = "hello ";
        String body = "world\r\n";
        for (int i = 0; i < 10; i++) {
            long label = System.currentTimeMillis();
            if (writeSplit) {
                out.write(head.getBytes());
                out.write(body.getBytes());
            }
            else {
                out.write((head + body).getBytes());
            }
            String line = reader.readLine();
            System.out.println("RTT:" + (System.currentTimeMillis() - label) + " ,receive:" + line);
        }
        in.close();
        out.close();
        socket.close();
    }

}

 

   客户端通过一个writeSplit变量来控制是否分开写head和body，如果为true，则先写head再写body，否则将head加上body一次写入。客户端的逻辑也很简单，连上服务器，发送一行，等待应答并打印RTT，循环10次最后关闭连接。

   首先，我们将writeSplit设置为true，也就是分两次写入一行，在我本机测试的结果，我的机器是ubuntu 11.10：

WriteSplit:true
RTT:8 ,receive:hello world
RTT:40 ,receive:hello world
RTT:40 ,receive:hello world
RTT:40 ,receive:hello world
RTT:39 ,receive:hello world
RTT:40 ,receive:hello world
RTT:40 ,receive:hello world
RTT:40 ,receive:hello world
RTT:40 ,receive:hello world
RTT:40 ,receive:hello world

 

    可以看到，每次请求到应答的时间间隔都在40ms，除了第一次。linux的delayed ack是40ms，而不是原来以为的200ms。第一次立即ACK，似乎跟linux的quickack mode有关，这里我不是特别清楚，有比较清楚的同学请指教。

     接下来，我们还是将writeSplit设置为true，但是客户端禁用nagle算法，也就是客户端代码在connect之前加上一行：

        Socket socket = new Socket();
        socket.setTcpNoDelay(true);
        socket.connect(new InetSocketAddress(host, 8000));

 

    再跑下测试：

WriteSplit:true
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world
RTT:1 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world

 

   这时候就正常多了，大部分RTT时间都在1毫秒以下。果然禁用Nagle算法可以解决延迟问题。
   如果我们不禁用nagle算法，而将writeSplit设置为false，也就是将head和body一次写入，再次运行测试（记的将setTcpNoDelay这行删除）：

WriteSplit:false
RTT:7 ,receive:hello world
RTT:1 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world
RTT:0 ,receive:hello world

 

   结果跟禁用nagle算法的效果类似。既然这样，我们还有什么理由一定要禁用nagle算法呢？通过我在xmemcached的 压测中的测试，启用nagle算法在小数据的存取上甚至有一定的效率优势，memcached协议本身就是个连续的请求应答的模型。上面的测试如果在 windows上跑，会发现RTT最大会在200ms以上，可见winsock的delayed ack超时是200ms。

   最后一个问题，什么情况下才应该禁用nagle算法？当你的应用不是这种连续的请求——应答模型，而是需要实时地单向发送很多小数据的时候或者请求是有间 隔的，则应该禁用nagle算法来提高响应性。一个最明显是例子是telnet应用，你总是希望敲入一行数据后能立即发送给服务器，然后马上看到应答，而 不是说我要连续敲入很多命令或者等待200ms才能看到应答。

   上面是我对nagle算法和delayed ack的理解和测试，有错误的地方请不吝赐教。

没啥人关注啊，我写了一下午的

哈哈，除了那几批“老人”外，没几人对TCP/Socket熟悉的。 你叫人怎么关注呀~~~~

不错，投了精华！

多学习了一点内容，以前还不知道有delay ack这回事。

有个问题：在memcached协议里，对应的cmd都是一次请求request出去。不知道在xmemcached会出现head,body的情况？

还有一个，就是比较关心LZ是怎么发现这个问题原因？貌似是个性能改进点，并不会造成功能不可用。要发现这个问题，可得下不少功夫，蹲点tcpdump?

good job，我的程序里面也是write header write body，然后wait response的模式，现在我把客户端程序用bufferedOutPutStream缓存header body一起发送。

首先是xmemcached不会有这种问题，它都是搞成一个缓冲区来发送的，也没有用writev。
其次，这个问题过去一直都有存在，都是简单地设置nagle算法来解决。最近回去看了些tcp/ip的资料（tcp/ip协议卷一），发现这样解决不是最好和唯一的办法。

可能在memcached client这样的场景下也许不会出现这样的情况。 nio每次的write都操作一个sendBuffer，如果一次flush不能完全输出，还是会出现的write-write情况，写类似的server，比如大文本数据下载，大数据量的rpc请求服务，就得注意LZ提的场景。

不过看了下目前公司的几个socket操作的包，基本都是Nagle=false的为多。

文章太长，只看了一半。

不过有个疑问，TCP是有捎带ACK。但是绝大多数实现采用的时延为200ms，也就是说，TCP将以最大200ms的时延等待是否有数据一起发送。

你在本机测试时RTT很小觉得有阻塞，但是200ms对于网络传输来说并不是很大吧。

还有个疑问，在一个web应用里面，既存在小数据量得http请求，也存在大数据量的文件上传，第二种情况write不能合并，服务器也不会马上响应，那这种情况怎么解决？当前的nginx,tomcat等服务器是怎么做的呢？