亚洲欧洲中文日韩久久AV乱码,亚洲精品国产精品乱码不卡√,亚洲伊人久久大香线蕉综合图片

dennis — Tue, 15 Nov 2011 23:34:00 GMT

今天看到的一个演�C�TCP慢启动和滑动�H�口机制的动画，很�Ş�?br /> osischool.com

dennis 2011-11-16 07:34 发表评论

dennis — Thu, 30 Jun 2011 08:01:00 GMT

Nagle��法的立意是良好的，避免�|�络中充塞小��包�Q�提高网�l�的利用率。但是当Nagle��法遇到delayed ACK悲剧��发生了。Delayed ACK的本意也是�ؓ了提高TCP性能�Q�跟应答数据捎带上ACK�Q�同旉��?a >�p�涂�H�口�l�合�?/a>�Q�也可以一个ack��认多个�D�|��节省开销�?br /> 悲剧发生在这�U�情况，假设一端发送数据�ƈ�{�待另一端应�{�，协议上分为头部和数据�Q�发送的时候不�q�地选择了write-write�Q�然后再read�Q�也��是先发送头部，再发送数据，最后等待应�{�。发送端的伪代码是这�?br />

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

接收端的处理代码�c�M��q�样�Q?br />

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

   �q�里假设head和body都比较小�Q�当默认启用nagle��法�Q��ƈ且是�W�一�ơ发送的时候，�Ҏ��nagle��法�Q�第一个段head可以立即发送，因�ؓ没有�{�待��认的段�Q�接收端收到head�Q�但是包不完��_��l�箋�{�待body辑ֈ��q��g�q�ACK�Q�发送端�l�箋写入body�Q�这时候nagle��法起作用了�Q�因为head�q�没有被ACK�Q�所以body要�g�q�发送。这��造成了发送端和接收端都在�{�待�Ҏ��发送数据的现象�Q�发送端�{�待接收端ACK head以便�l�箋发送body�Q�而接收端在等待发送方发送body�q��g�q�ACK�Q�悲剧的无以�a�语。这�U�时候只有等待一端超时�ƈ发送数据才能��l�往下走�?br />
   正因为nagle��法和delayed ack的媄响，再加上这�U�write-write-read的编�E�方式造成了很多网贴在讨论��Z��么自己写的网�l�程序性能那么差。然后很多�h会在帖子里徏议禁用Nagle��法吧，讄��TCP_NODELAY为true卛_��用nagle��法。但是这真的是解决问题的唯一办法和最好办法吗�Q?br />
   其实问题不是出在nagle��法�w�上的，问题是出在write-write-read�q�种应用�~�程上。禁用nagle��法可以暂时解决问题�Q�但是禁用nagle��法也带来很大坏处，�|�络中充塞着��封包，�|�络的利用率上不去，在极端情况下�Q�大量小��包��D��|�络拥塞甚至崩溃。因此，能不��止�q�是不禁止的好，后面我们会说下什么情况下才需要禁用nagle��法。对大多数应用来��_��一般都是连�l�的��h��——应答模型�Q�有��h��同时有应�{�，那么��h��包的ACK其实可以延迟到跟响应一起发送，在这�U�情况下�Q�其实你只要避免write-write-read形式的调用就可以避免延迟现象�Q�利用writev做聚集写或者将head和body一起写�Q�然后再read�Q�变成write-read-write-read的�Ş式来调用�Q�就无需��用nagle��法也可以做��C��延迟�?br />
   writev是系�l�调用，在Java里是用到GatheringByteChannel.write(ByteBuffer[] srcs, int offset, int length)�Ҏ��来做聚集写。这里可能还有一点值的提下�Q�很多同学看java nio框架几乎都不用这个writev调用�Q�这是有原因的。主要是因�ؓJava的write本��n对ByteBuffer有做临时�~�存�Q�而writev没有做缓存，��D��试来看write反而比writev更高效，因此通常会更推荐用户��head和body攑ֈ�同一个Buffer里来避免调用writev�?br />
   下面我们��做个实际的代码��试来结束讨论。这个例子很��单，客户端发送一行数据到服务器，服务器简单地��这行数据返回。客��L��发送的时候可以选择分两�ơ发�Q�还是一�ơ发送。分两次发就是write-write-read�Q�一�ơ发��是write-read-write-read�Q�可以看看两�U��Ş式下延迟的差异�?strong>注意�Q�在windows上测试下面的代码�Q�客��L��和服务器必须分在两台机器上，��g��winsock对loopback�q�接的处理不一栗��?/strong>

    服务器源码：

服务端绑定到本地8000端口�Q��ƈ监听�q�接�Q�连上来的时候就��d��d��一行数据，�q�将数据�q�回�l�客��L��?br />
客户端代码：

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�Q�如果�ؓtrue�Q�则先写head再写body�Q�否则将head加上body一�ơ写入。客��L��的逻辑也很��单，�q�上服务器，发送一行，�{�待应答�q�打印RTT�Q��@�?0�ơ最后关闭连接�?br />
首先�Q�我们将writeSplit讄��为true�Q�也��是分两�ơ写入一行，在我本机��试的结果，我的机器是ubuntu 11.10�Q?br />

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

可以看到�Q�每�ơ请求到应答的时间间隔都�?0ms�Q�除了第一�ơ。linux的delayed ack�?0ms�Q�而不是原来以为的200ms。第一�ơ立即ACK�Q�似乎跟linux的quickack mode有关�Q�这里我不是特别清楚�Q�有比较清楚的同学请指教�?br />
接下来，我们�q�是��writeSplit讄��为true�Q�但是客��L��用nagle��法�Q�也��是客户端代码在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

�q�时候就正常多了�Q�大部分RTT旉��都在1毫秒以下。果然禁用Nagle��法可以解决延迟问题�?br /> 如果我们不禁用nagle��法�Q�而将writeSplit讄��为false�Q�也��是��head和body一�ơ写入，再次�q�行��试�Q�记的将setTcpNoDelay�q�行删除�Q�：

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

   �l�果跟禁用nagle��法的效果类伹{��既然这��P��我们�q�有什么理�׃��定要��用nagle��法呢？通过我在xmemcached的压��中的测试，启用nagle��法在小数据的存取上甚至有一定的效率优势�Q�memcached协议本��n��是个连�l�的��h��应答的模型。上面的��试如果在windows上跑�Q�会发现RTT最大会�?00ms以上�Q�可见winsock的delayed ack��时�?00ms�?br />
   最后一个问题，什么情况下才应该禁用nagle��法�Q�当你的应用不是�q�种�q�箋的请�?#8212;—应答模型�Q�而是需要实时地单向发送很多小数据的时候或者请求是有间隔的�Q�则应该��用nagle��法来提高响应性。一个最明显是例子是telnet应用�Q�你��L��希望敲入一行数据后能立卛_��送给服务器，然后马上看到应答�Q�而不是说我要�q�箋敲入很多命��o或者等�?00ms才能看到应答�?br />
   上面是我对nagle��法和delayed ack的理解和��试�Q�有错误的地方请不吝赐教�?br />
   转蝲��h��明出处：http://www.tkk7.com/killme2008/archive/2011/06/30/353441.html

dennis 2011-06-30 16:01 发表评论

Java NIO�~�程的技巧和陷阱

dennis — Thu, 30 Jun 2011 03:07:00 GMT

��d��做的分��n�Q�一直上传slideshare��p�|�Q�今天又试了下，成功了。这个主题主要介�l�Java NIO�~�程的技巧和陷阱�Q�解��M��一些NIO框架的源码，以及�~�写高性能NIO�|�络框架所需要注意的技巧和�~�陷。关注这斚w��的朋友可以看一下。去�q�写了篇blog提供了pdf版本的下载，�?a href="http://www.tkk7.com/killme2008/archive/2010/11/22/338420.html">�q�里�?br />

Nio trick and trap

View more presentations from dennis zhuang

dennis 2011-06-30 11:07 发表评论

Unix domain socket和memcached

dennis — Wed, 14 Oct 2009 22:12:00 GMT

    unix域协议�ƈ不是一个实际的协议族，而是在单个主��Z��执行客户�Q�服务器通信的一�U�方法，是IPC的方法之一�Q�特定于*nix�q�_��。��用unix domain socket有三个好处：
1�Q�在同一��L��上，unix domain socket比一般的tcp socket快上一倍，性能因素�q�是一个主要原因�?br /> 2�Q�unix domain socket可以在同一��L��的不同进�E�之间传递文件描�q�符
3�Q�较新的unix domain socket实现把客��L��ID和组ID提供�l�服务器�Q�可以让服务器作安全��查�?br />
   memcached的FAQ中也提到��Z��安全验证�Q�可以考虑让memcached监听unix domain socket。Memcached支持�q�一点，可以通过-s选项指定unix domain socket的�\径名�Q�注意，��Z��可移植性，��量使用�l�对路径�Q�因为Posix标准声称�l�unix domain socket�l�定相对路径��导致不可预计的后果�Q�我在linux的测试是可以使用相对路径。假设我��memcached�l�定�?home/dennis/memcached�Q�可以这样启动memcached:

memcached -s /home/dennis/memcached

端口呢？没有端口了，/home/dennis/memcached�q�个文�g你可以理解成FIFO的管道，unix domain socket的server/client通过�q�个��道通讯�?br />
   libmemcached支持通过unix domain socket来访问memcached�Q�基于libmemcached实现的client应该都可以��用这一功能。目前来看，java�q�_��׃��不支持��^台相关的unix domain socket�Q�因此无法��n受memcached的这一�Ҏ��?br />
   不过有一个开源项目通过jni支持实现了unix domain socket�Q�这个项目称�?a title="juds" >juds。核心类��׃��个，使用非常��单。下载文件后�Q�解压羃�Q�make & make install卛_��。注意，Makefile中写��M��JAVA_HOME�Q�手工修改即可。看一个例子，�l�典的Time server:

package com.google.code.juds.test;

import java.io.IOException;

import com.google.code.juds.*;
import java.io.*;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TimeServer {
    public static void main(String[] args) {
        try {
            UnixDomainSocketServer server = new UnixDomainSocketServer(
                    "/home/dennis/time", UnixDomainSocket.SOCK_STREAM);
            OutputStream output = server.getOutputStream();
             Date date = new Date();
             DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            output.write(dateFormat.format(date).getBytes());
        } catch (IOException e) {
                    e.printStackTrace();
        }

    }

}

通过UnixDomainSocketServer创徏server�Q�指定类型�ؓSOCK_STREAM�Q�juds也支持UDP�c�d��。client的��用如�?

        byte[] b = new byte[128];
        UnixDomainSocketClient socket = new UnixDomainSocketClient("/home/dennis/time",
                UnixDomainSocket.SOCK_STREAM);
        InputStream in = socket.getInputStream();
        in.read(b);
        System.out.println("Text received: \"" + new String(b) + "\"");
        socket.close();

昄��Q�juds�q�只支持��d��IO�Q�考虑可进一步��用select、poll来扩展实现非��d��IO�?br />
最后一个例子，通过juds讉K��memcached的unix domain socket�Q�简单的version协议调用�Q?br />

byte[] b = new byte[128];
        UnixDomainSocketClient socket = new UnixDomainSocketClient("/home/dennis/memcached",
                UnixDomainSocket.SOCK_STREAM);
        OutputStream out = socket.getOutputStream();
        String text = "version\r\n";
        out.write(text.getBytes());
        InputStream in = socket.getInputStream();
        in.read(b);
        System.out.println("Text received: \"" + new String(b) + "\"");
        socket.close();

输出
Text received: "VERSION 1.4.1"

dennis 2009-10-15 06:12 发表评论

dennis — Tue, 03 Feb 2009 07:40:00 GMT

ACE_Reactor在windows上默认不是��用ACE_Select_Reactor�Q�而是ACE_WFMO_Reactor�Q�封装了WaitForMultipleObjects和WSAEventSelect�Q�。如果想选择ACE_Select_Reactor�Q�如�Q?br />

ACE_Select_Reactor select_reactor;
ACE_Reactor reactor (&select_reactor);

那么VC需要启�?GR�~�译选项�Q�具体做法就是在��目属性c/c++的语�a�一栏中启用RTTI信息卛_��。在选择了ACE_Select_Reactor之后�Q�启动进�E�后在ProcessExplorer果然可以看到�q�程的TCP属性中建立了两个互�q�的TCP�q�接�Q�用以notify的实现�?br />

dennis 2009-02-03 15:40 发表评论

ACE Reactor的Echo Server

dennis — Tue, 03 Feb 2009 03:59:00 GMT

相对完整的修改版�?br />

  1 /************************************************************************
  2 * @file: echo.cpp
  3 * @author: dennis
  4 * @revise: dennis  http://www.tkk7.com/killme2008
  5 *          相对完整的echo server�Q�可以接受多个客��L��q�接�Q��ƈ且可以通过键入quit正常关闭
  6
  7 ************************************************************************/
  8
  9 #ifdef _DEBUG
10 #pragma comment (lib,"aced.lib")
11 #else
12 #pragma comment (lib,"ace.lib")
13 #endif
14
15 #include "ace/Reactor.h"
16 #include "ace/SOCK_Acceptor.h"
17 #include "ace/os.h"
18 #include "ace/Log_Msg.h"
19 #include "ace/inet_addr.h"
20 #include "ace/Thread_Manager.h"
21 #include<iostream>
22 #include<string>
23
24 #define PORT_NO 8080
25 typedef ACE_SOCK_Acceptor Acceptor;
26 //forward declaration
27 class Echo_Handler;
28
29 class Echo_Handler:public ACE_Event_Handler
30 {
31 public:
32     //construcor
33     Echo_Handler()
34     {
35     }
36     virtual ~Echo_Handler()
37     {
38     }
39     //Called back to handle any input received
40     int handle_input(ACE_HANDLE)
41     {
42         //receive the data
43         ssize_t recvBytes = peer().recv(data,12);
44         if(recvBytes <= 0)
45         {
46             ACE_DEBUG((LM_DEBUG,"%s\n","客户端断开�q�接"));
47             return -1;
48         }
49         data[recvBytes] = 0;
50
51         ACE_DEBUG((LM_DEBUG,"%s\n",data));
52
53
54         if(ACE_OS::strcmp(data,"q") == 0)
55         {
56             ACE_DEBUG((LM_DEBUG,"%s\n","客户端退�?/span>"));
57             peer().close();
58             return -1;
59         }
60         peer().send_n(data,recvBytes);
61         // do something with the input received.
62         //
63         // keep yourself registerd with the reator
64         return 0;
65     }
66
67     int handle_close(ACE_HANDLE h,ACE_Reactor_Mask m)
68     {
69         delete this;
70         return  0;
71     }
72
73     //Used by the reactor to determine the underlying handle
74     ACE_HANDLE get_handle()  const
75     {
76         return this->peer_.get_handle();
77     }
78
79     //Returns a reference to the underlying stream.
80     ACE_SOCK_Stream& peer()
81     {
82         return this->peer_;
83     }
84
85 private:
86     ACE_SOCK_Stream peer_;
87     char data [12];
88 };
89
90 class Echo_Accept_Handler:public ACE_Event_Handler
91 {
92 public:
93     //Constructor
94     Echo_Accept_Handler(ACE_Addr &addr)
95     {
96         this->open(addr);
97     }
98     virtual ~Echo_Accept_Handler(){}
99     //Open the peer_acceptor so it starts to "listen"
100     //for incoming clients
101     int open(ACE_Addr &addr)
102     {
103         if(peer_acceptor.open(addr)==-1)
104             ACE_ERROR_RETURN((LM_ERROR,"启动服务器错误\n"),1);
105         return 0;
106     }
107
108     //Overload the handle input method
109     int handle_input(ACE_HANDLE handle)
110     {
111         //Client has requested connection to server.
112         //Create a handler to handle the connection
113         Echo_Handler *eh;
114         ACE_NEW_RETURN(eh,Echo_Handler,-1);
115         ACE_INET_Addr cliaddr;
116         //Accept the connection "into" the Event Handler
117         if(this->peer_acceptor.accept(eh->peer(),//stream
118             &cliaddr,//remote address
119             0,//timeout
120             1) == -1)//restart if interrupted
121             ACE_DEBUG((LM_ERROR,"Error in connection \n"));
122
123         ACE_DEBUG((LM_DEBUG,"�q�接已经建立,来自%s\n",cliaddr.get_host_addr()));
124
125         //Register the input event handler for reading
126         ACE_Reactor::instance()->register_handler(eh,ACE_Event_Handler::READ_MASK);
127         const char* msg = "按q键��服务安全退出\r\n";
128         eh->peer().send_n(msg,strlen(msg)+1);
129         return 0;
130     }
131
132     //Used by the reactor to determine the underlying handle
133     ACE_HANDLE get_handle(void) const
134     {
135         return this->peer_acceptor.get_handle();
136     }
137     int handle_close(ACE_HANDLE h,ACE_Reactor_Mask m){
138         peer_acceptor.close();
139         delete this;
140         return 0;
141     }
142
143 private:
144     Acceptor peer_acceptor;
145 };
146 class Quit_Handler:public ACE_Event_Handler
147 {
148 public:
149     Quit_Handler(ACE_Reactor* r):ACE_Event_Handler(r){}
150     virtual int handle_exception(ACE_HANDLE)
151     {
152         ACE_DEBUG((LM_DEBUG,"停止服务器中\n"));
153         reactor()->end_reactor_event_loop();
154         return -1;
155     }
156     int handle_close(ACE_HANDLE h,ACE_Reactor_Mask m)
157     {
158         delete this;
159         return 0;
160     }
161     virtual ~Quit_Handler(){}
162 };
163 static ACE_THR_FUNC_RETURN run_events (void *arg);
164 static ACE_THR_FUNC_RETURN controller (void *arg);
165 int ACE_TMAIN(int argc,char *argv[])
166 {
167
168     ACE_Reactor* reactor=ACE_Reactor::instance();
169     if(ACE_Thread_Manager::instance()->spawn(run_events,reactor,THR_DETACHED | THR_SCOPE_SYSTEM)==-1)
170         return 1;
171     if(ACE_Thread_Manager::instance()->spawn(controller,reactor,THR_DETACHED | THR_SCOPE_SYSTEM)==-1)
172         return 1;
173     return ACE_Thread_Manager::instance()->wait();
174 }
175
176 static ACE_THR_FUNC_RETURN run_events (void *arg)
177 {
178     ACE_Reactor* reactor=ACE_static_cast(ACE_Reactor*,arg);
179     ACE_INET_Addr addr(PORT_NO);
180
181     Echo_Accept_Handler *eh=0;
182     ACE_NEW_RETURN(eh,Echo_Accept_Handler(addr),1);
183
184     ACE_Reactor::instance()->owner(ACE_OS::thr_self());
185     reactor->register_handler(eh,ACE_Event_Handler::ACCEPT_MASK);
186     ACE_Reactor::instance()->run_reactor_event_loop();
187     return 0;
188 }
189 static ACE_THR_FUNC_RETURN controller (void *arg)
190 {
191     ACE_Reactor* reactor=ACE_static_cast(ACE_Reactor*,arg);
192     Quit_Handler *quit_handler=0;
193     ACE_NEW_RETURN(quit_handler,Quit_Handler(reactor),1);
194     for(;;)
195     {
196         std::string line;
197         std::getline(std::cin,line,'\n');
198         if(line=="quit"){
199             ACE_DEBUG((LM_DEBUG,"��h��停止服务器\n"));
200             reactor->notify(quit_handler);
201             break;
202         }
203     }
204     return 0;
205 }
206

dennis 2009-02-03 11:59 发表评论