java nio bio aio

最新推荐文章于 2024-09-15 13:15:19 发布

lalioCAT

最新推荐文章于 2024-09-15 13:15:19 发布

阅读量811

点赞数

分类专栏： JAVA 文章标签： nio java

JAVA 专栏收录该内容

29 篇文章

订阅专栏

本文详细介绍了Java中的同步阻塞I/O (BIO)、同步非阻塞I/O (NIO) 和异步非阻塞I/O (AIO) 的概念与区别。重点对比了BIO与NIO的不同之处，并解释了AIO如何实现更高效的异步处理。通过具体的Java代码示例展示了如何使用NIO中的通道(Channel)和选择器(Selector)进行高效的数据通信。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

转自：http://blog.youkuaiyun.com/liuxiao723846/article/details/45066095

java中的IO主要源自于网络和本地文件

IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO

在JDK1.4出来之前，我们建立网络连接的时候采用BIO模式，需要先在服务端启动一个ServerSocket，然后在客户端启动Socket来对服务端进行通信，默认情况下服务端需要对每个请求建立一堆线程等待请求，而客户端发送请求后，先咨询服务端是否有线程相应，如果没有则会一直等待或者遭到拒绝请求，如果有的话，客户端会线程会等待请求结束后才继续执行。

BIO与NIO一个比较重要的不同，是我们使用BIO的时候往往会引入多线程，每个连接一个单独的线程；而NIO则是使用单线程或者只使用少量的多线程，每个连接共用一个线程。

NIO的最重要的地方是当一个连接创建后，不需要对应一个线程，这个连接会被注册到多路复用器上面，所以所有的连接只需要一个线程就可以搞定，当这个线程中的多路复用器进行轮询的时候，发现连接上有请求的话，才开启一个线程进行处理，也就是一个请求一个线程模式。

在NIO的处理方式中，当一个请求来的话，开启线程进行处理，可能会等待后端应用的资源(JDBC连接等)，其实这个线程就被阻塞了，当并发上来的话，还是会有BIO一样的问题。

AIO：　　

HTTP/1.1出现后，有了Http长连接，这样除了超时和指明特定关闭的http header外，这个链接是一直打开的状态的，这样在NIO处理中可以进一步的进化，在后端资源中可以实现资源池或者队列，当请求来的话，开启的线程把请求和请求数据传送给后端资源池或者队列里面就返回，并且在全局的地方保持住这个现场(哪个连接的哪个请求等)，这样前面的线程还是可以去接受其他的请求，而后端的应用的处理只需要执行队列里面的就可以了，这样请求处理和后端应用是异步的.当后端处理完，到全局地方得到现场，产生响应，这个就实现了异步处理。

BIO是一个连接一个线程。

　 NIO是一个请求一个线程。

　 AIO是一个有效请求一个线程。

大家都知道自从jdk5开始，java中多了java.nio和java.util.concurent包，这两个包可谓威力无穷啊，像tomcat最新版本(用了concurrent包)，mina等纷纷在此基础上进行了更新(mina更是直接就通过java.nio来实现的)。其实nio说起来很简单。java通信的基础是socket.和serversocket 在此基础上封装一下，就是socketchannel和serversocketchannel,封装成channel的最大好处就是可以实现non-blocking的通信。然后再加入了一个多路轮询机制，通过观察者模式使得通过单线程就可以同时管理多个channel. 明白了这些之后，放出我的例子来。分别使用socket,channel,selector

实现了java的通信。

Server：

[java]view plain copy 
   
 
 import java.io.IOException;    
 import java.net.InetSocketAddress;    
 import java.net.ServerSocket;    
 import java.net.Socket;    
 import java.nio.ByteBuffer;    
 import java.nio.channels.*;    
 import java.util.Set;    
     
     
 public class TestChannel {    
     public static void main(String args[]) throws IOException{    
         TestChannel tt=new TestChannel();    
         //tt.initServerChannel(992);    
         tt.initSelector(992);    
     }    
         
     //最初的java  socket实现方式，直接通过serversocket和socket通信    
     public void initServerSocket(int port) throws IOException{    
         ServerSocketChannel ssc=ServerSocketChannel.open();    
         //ssc.configureBlocking(false);    
         ServerSocket ss=new ServerSocket(port);    
         while(true){    
             Socket socket=ss.accept();    
                 System.out.println("socket accepted");    
                 byte[] buf=new byte[1024];    
                 try{    
                 socket.getInputStream().read(buf);    
                 }    
                 catch(Exception ex){    
                     socket.close();    
                 }    
                 System.out.println(new String(buf));    
                 
         }    
     }    
     //通过Channel实现的non-blocking通信方式    
     public void initServerChannel(int port) throws IOException{    
         ServerSocketChannel ssc=ServerSocketChannel.open();    
         ssc.configureBlocking(false);    
         ServerSocket ss=ssc.socket();    
         ss.bind(new InetSocketAddress(port));    
         while(true){    
             SocketChannel sc=ssc.accept();    
             if(sc!=null){    
                 Socket socket=sc.socket();    
                 System.out.println("socket accepted");    
                 byte[] buf=new byte[1024];    
                 try{    
                 socket.getInputStream().read(buf);    
                 }    
                 catch(Exception ex){    
                     socket.close();    
                 }    
                 System.out.println(new String(buf));    
             }    
         }    
     }    
     //通过selector和channel进行multiplexed通信,像mina就是通过这种方式实现的    
     public void initSelector(int port) throws IOException{    
         Selector selector=Selector.open();    
         //register server channel    
         ServerSocketChannel ssc=ServerSocketChannel.open();    
         ssc.configureBlocking(false);    
         ServerSocket ss=ssc.socket();    
         ss.bind(new InetSocketAddress(port));    
         ssc.register(selector, SelectionKey.OP_ACCEPT);    
         while(true){    
             int interestNo=selector.select();    
             if(interestNo==0)    
                 continue;    
             Set<SelectionKey> keys=selector.selectedKeys();    
             for(SelectionKey key:keys){    
                 //接受Socket连接请求    
                 if(key.isAcceptable()){    
                     SocketChannel sc=ssc.accept();    
                     try{    
                     sc.configureBlocking(false);    
                     sc.register(selector, SelectionKey.OP_READ);    
                     }    
                     catch(Exception ex){    
                         sc.close();    
                     }    
                     System.out.println("connection accepted");    
                     keys.remove(key);    
                 }    
                 else if(key.isReadable()){    
                     SocketChannel sc=(SocketChannel)key.channel();    
                     ByteBuffer bbuf=ByteBuffer.allocate(1024);    
                     try{    
                     sc.read(bbuf);    
                     }    
                     catch(Exception ex){    
                         sc.close();    
                     }    
                     System.out.println(new String(bbuf.array()));    
                     keys.remove(key);    
                 }    
                 else    
                     keys.remove(key);    
                     continue;    
                         
                 }    
             }    
         }    
     }  

client:

[java]view plain copy 
   
 
 public class TestChannelClient {    
 public static void main(String args[]) throws UnknownHostException, IOException{    
     Socket sc=new Socket("127.0.0.1",992);    
     OutputStream out=sc.getOutputStream();    
     out.write("hello".getBytes());    
     out.flush();    
 }    
 }    