JAVA的BIO，NIO，AIO

1this.asynchronousChannelGroup=AsynchronousChannelGroup
2.withCachedThreadPool(Executors.newCachedThreadPool(),
3this.threadPoolSize);

1this.serverSocketChannel=AsynchronousServerSocketChannel
2.open(this.asynchronousChannelGroup);
3

1this.serverSocketChannel
2.setOption(
3StandardSocketOption.SO_REUSEADDR,true);
4this.serverSocketChannel
5.setOption(
6StandardSocketOption.SO_RCVBUF,16*1024);
7

1this.serverSocketChannel
2.bind(newInetSocketAddress("localhost",8080),100);

1publicvoidpendingAccept(){
2if(this.started&&this.serverSocketChannel.isOpen()){
3this.acceptFuture=this.serverSocketChannel.accept(null,
4newAcceptCompletionHandler());
5
6}else{
7thrownewIllegalStateException("Controllerhasbeenclosed");
8}
9}
10

1privatefinalclassAcceptCompletionHandlerimplements
2CompletionHandler<AsynchronousSocketChannel,Object>{
3
4@Override
5publicvoidcancelled(Objectattachment){
6logger.warn("Acceptoperationwascanceled");
7}
8
9@Override
10publicvoidcompleted(AsynchronousSocketChannelsocketChannel,
11Objectattachment){
12try{
13logger.debug("Acceptconnectionfrom"
14+socketChannel.getRemoteAddress());
15configureChannel(socketChannel);
16AioSessionConfigsessionConfig=buildSessionConfig(socketChannel);
17Sessionsession=newAioTCPSession(sessionConfig,
18AioTCPController.this.configuration
19.getSessionReadBufferSize(),
20AioTCPController.this.sessionTimeout);
21session.start();
22registerSession(session);
23}catch(Exceptione){
24e.printStackTrace();
25logger.error("Accepterror",e);
26notifyException(e);
27}finally{
28<strong>pendingAccept</strong>();
29}
30}
31
32@Override
33publicvoidfailed(Throwableexc,Objectattachment){
34logger.error("Accepterror",exc);
35try{
36notifyException(exc);
37}finally{
38<strong>pendingAccept</strong>();
39}
40}
41}
42

1publicclassAioTCPSession{
2protectedvoidstart0(){
3pendingRead();
4}
5
6protectedfinalvoidpendingRead(){
7if(!isClosed()&&this.asynchronousSocketChannel.isOpen()){
8if(!this.readBuffer.hasRemaining()){
9this.readBuffer=ByteBufferUtils
10.increaseBufferCapatity(this.readBuffer);
11}
12this.readFuture=this.asynchronousSocketChannel.read(
13this.readBuffer,this,this.readCompletionHandler);
14}else{
15thrownewIllegalStateException(
16"SessionOrChannelhasbeenclosed");
17}
18}
19
20}
21

1publicfinalclassReadCompletionHandlerimplements
2CompletionHandler<Integer,AbstractAioSession>{
3
4privatestaticfinalLoggerlog=LoggerFactory
5.getLogger(ReadCompletionHandler.class);
6protectedfinalAioTCPControllercontroller;
7
8publicReadCompletionHandler(AioTCPControllercontroller){
9this.controller=controller;
10}
11
12@Override
13publicvoidcancelled(AbstractAioSessionsession){
14log.warn("Session("+session.getRemoteSocketAddress()
15+")readoperationwascanceled");
16}
17
18@Override
19publicvoidcompleted(Integerresult,AbstractAioSessionsession){
20if(log.isDebugEnabled())
21log.debug("Session("+session.getRemoteSocketAddress()
22+")read+"+result+"bytes");
23if(result<0){
24session.close();
25return;
26}
27try{
28if(result>0){
29session.updateTimeStamp();
30session.getReadBuffer().flip();
31session.decode();
32session.getReadBuffer().compact();
33}
34}finally{
35try{
36session.pendingRead();
37}catch(IOExceptione){
38session.onException(e);
39session.close();
40}
41}
42controller.checkSessionTimeout();
43}
44
45@Override
46publicvoidfailed(Throwableexc,AbstractAioSessionsession){
47log.error("Sessionreaderror",exc);
48session.onException(exc);
49session.close();
50}
51
52}
53

1if(null!=this.readFuture){
2this.readFuture.cancel(true);
3}
4this.asynchronousSocketChannel.close();
5

1protectedvoidwrite0(WriteMessagemessage){
2booleanneedWrite=false;
3synchronized(this.writeQueue){
4needWrite=this.writeQueue.isEmpty();
5this.writeQueue.offer(message);
6}
7if(needWrite){
8pendingWrite(message);
9}
10}
11
12protectedfinalvoidpendingWrite(WriteMessagemessage){
13message=preprocessWriteMessage(message);
14if(!isClosed()&&this.asynchronousSocketChannel.isOpen()){
15this.asynchronousSocketChannel.write(message.getWriteBuffer(),
16this,this.writeCompletionHandler);
17}else{
18thrownewIllegalStateException(
19"SessionOrChannelhasbeenclosed");
20}
21}
22

1@Override
2publicvoidcompleted(Integerresult,AbstractAioSessionsession){
3if(log.isDebugEnabled())
4log.debug("Session("+session.getRemoteSocketAddress()
5+")writen"+result+"bytes");
6
7WriteMessagewriteMessage;
8Queue<WriteMessage>writeQueue=session.getWriteQueue();
9synchronized(writeQueue){
10writeMessage=writeQueue.peek();
11if(writeMessage.getWriteBuffer()==null
12||!writeMessage.getWriteBuffer().hasRemaining()){
13writeQueue.remove();
14if(writeMessage.getWriteFuture()!=null){
15writeMessage.getWriteFuture().setResult(Boolean.TRUE);
16}
17try{
18session.getHandler().onMessageSent(session,
19writeMessage.getMessage());
20}catch(Exceptione){
21session.onException(e);
22}
23writeMessage=writeQueue.peek();
24}
25}
26if(writeMessage!=null){
27try{
28session.pendingWrite(writeMessage);
29}catch(IOExceptione){
30session.onException(e);
31session.close();
32}
33}
34}
35

java.io

java.nio

non-blockingI/O

Tomcat安装目录/conf/server.xml

<Connectorport="8080"protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443"/>

org.apache.coyote.http11.Http11NioProtocol

<Connectorport="8080"protocol="org.apache.coyote.http11.Http11NioProtocol"
connectionTimeout="20000"
redirectPort="8443"/>

http-bio-8080

http-nio-8080

2013-8-616:17:49org.apache.catalina.core.AprLifecycleListenerinit
信息:TheAPRbasedApacheTomcatNativelibrarywhichallowsoptimalperformanceinproductionenvironmentswasnotfoundonthejava.library.path:xxx/xxx(这里是路径信息)

Connector

protocol

org.apache.coyote.http11.Http11AprProtocol

tcnative-1.dll

Tomcat6.x版本从6.0.32开始就默认支持apr。
Tomcat7.x版本从7.0.30开始就默认支持apr。
因此，如果读者使用的Tomcat版本比较陈旧的话，强烈建议升级到最新的稳定版本。

<Connectorport="80"protocol="org.apache.coyote.http11.Http11NioProtocol"
connectionTimeout="20000"
URIEncoding="UTF-8"
useBodyEncodingForURI="true"
enableLookups="false"
redirectPort="8443"/>

JavaBlockingConnectorJavaNioBlockingConnectorAPRConnector

ClassnameHttp11ProtocolHttp11NioProtocolHttp11AprProtocol

TomcatVersion3.x4.x5.x6.x6.x5.5.x6.x

SupportPollingNOYESYES

PollingSizeN/AUnlimited-RestrictedbymemUnlimited

ReadHTTPRequestBlockingBlockingBlocking

ReadHTTPBodyBlockingBlockingBlocking

WriteHTTPResponseBlockingBlockingBlocking

SSLSupportJavaSSLJavaSSLOpenSSL

SSLHandshakeBlockingNonblockingBlocking

MaxConnectionsmaxThreadsSeepollingsizeSeepollingsize

如果读者有socket的编程基础，应该会接触过堵塞socket和非堵塞socket，堵塞socket就是在accept、read、write等IO操作的的时候，如果没有可用符合条件的资源，不马上返回，一直等待直到有资源为止。而非堵塞socket则是在执行select的时候，当没有资源的时候堵塞，当有符合资源的时候，返回一个信号，然后程序就可以执行accept、read、write等操作，这个时候，这些操作是马上完成，并且马上返回。而windows的winsock则有所不同，可以绑定到一个EventHandle里，也可以绑定到一个HWND里，当有资源到达时，发出事件，这时执行的io操作也是马上完成、马上返回的。一般来说，如果使用堵塞socket，通常我们时开一个线程acceptsocket，当有socket链接的时候，开一个单独的线程处理这个socket；如果使用非堵塞socket，通常是只有一个线程，一开始是select状态，当有信号的时候马上处理，然后继续select状态。
　　
　　按照大多数人的说法，堵塞socket比非堵塞socket的性能要好。不过也有小部分人并不是这样认为的，例如Indy项目（Delphi一个比较出色的网络包），它就是使用多线程＋堵塞socket模式的。另外，堵塞socket比非堵塞socket容易理解，符合一般人的思维，编程相对比较容易。
　　
　　nio其实也是类似上面的情况。在JDK1.4，sun公司大范围提升Java的性能，其中NIO就是其中一项。Java的IO操作集中在java.io这个包中，是基于流的阻塞API（即BIO，BlockIO）。对于大多数应用来说，这样的API使用很方便，然而，一些对性能要求较高的应用，尤其是服务端应用，往往需要一个更为有效的方式来处理IO。从JDK1.4起，NIOAPI作为一个基于缓冲区，并能提供非阻塞O操作的API（即NIO，non-blockingIO）被引入。
　　
　　BIO与NIO一个比较重要的不同，是我们使用BIO的时候往往会引入多线程，每个连接一个单独的线程；而NIO则是使用单线程或者只使用少量的多线程，每个连接共用一个线程。
　　
　　这个时候，问题就出来了：我们非常多的java应用是使用ThreadLocal的，例如JSF的FaceContext、Hibernate的session管理、Struts2的Context的管理等等，几乎所有框架都或多或少地应用ThreadLocal。如果存在冲突，那岂不惊天动地？
　　
　　后来终于在Tomcat6的文档（http://tomcat.apache.org/tomcat-6.0-doc/aio.html）找到答案。根据上面说明，应该Tomcat6应用nio只是用在处理发送、接收信息的时候用到，也就是说，tomcat6还是传统的多线程Servlet，我画了下面两个图来列出区别：
　　
　　tomcat5：客户端连接到达->传统的SeverSocket.accept接收连接->从线程池取出一个线程->在该线程读取文本并且解析HTTP协议->在该线程生成ServletRequest、ServletResponse，取出请求的Servlet->在该线程执行这个Servlet->在该线程把ServletResponse的内容发送到客户端连接->关闭连接。
　　
　　我以前理解的使用nio后的tomcat6：客户端连接到达->nio接收连接->nio使用轮询方式读取文本并且解析HTTP协议（单线程）->生成ServletRequest、ServletResponse，取出请求的Servlet->直接在本线程执行这个Servlet->把ServletResponse的内容发送到客户端连接->关闭连接。
　　
　　实际的tomcat6：客户端连接到达->nio接收连接->nio使用轮询方式读取文本并且解析HTTP协议（单线程）->生成ServletRequest、ServletResponse，取出请求的Servlet->从线程池取出线程，并在该线程执行这个Servlet->把ServletResponse的内容发送到客户端连接->关闭连接。　
　　
　　
　　从上图可以看出，BIO与NIO的不同，也导致进入客户端处理线程的时刻有所不同：tomcat5在接受连接后马上进入客户端线程，在客户端线程里解析HTTP协议，而tomcat6则是解析完HTTP协议后才进入多线程，另外，tomcat6也比5早脱离客户端线程的环境。
　　
　　实际的tomcat6与我之前猜想的差别主要集中在如何处理servlet的问题上。实际上即使抛开ThreadLocal的问题，我之前理解tomcat6只使用一个线程处理的想法其实是行不同的。大家都有经验：servlet是基于BIO的，执行期间会存在堵塞的，例如读取文件、数据库操作等等。tomcat6使用了nio，但不可能要求servlet里面要使用nio，而一旦存在堵塞，效率自然会锐降。
　　　
　　
　　所以，最终的结论当然是tomcat6的servlet里面，ThreadLocal照样可以使用，不存在冲突。