BIO NIO AIO之间的区别

一、BIO、NIO、AIO的基本定义与类比描述：

BIO （Blocking I/O）：同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。这里使用那个经典的烧开水例子，这里假设一个烧开水的场景，有一排水壶在烧开水，BIO的工作模式就是， 叫一个线程停留在一个水壶那，直到这个水壶烧开，才去处理下一个水壶。但是实际上线程在等待水壶烧开的时间段什么都没有做。

NIO （New I/O）：同时支持阻塞与非阻塞模式，但这里我们以其同步非阻塞I/O模式来说明，那么什么叫做同步非阻塞？如果还拿烧开水来说，NIO的做法是叫一个线程不断的轮询每个水壶的状态，看看是否有水壶的状态发生了改变，从而进行下一步的操作。

AIO （ Asynchronous I/O）：异步非阻塞I/O模型。异步非阻塞与同步非阻塞的区别在哪里？异步非阻塞无需一个线程去轮询所有IO操作的状态改变，在相应的状态改变后，系统会通知对应的线程来处理。对应到烧开水中就是，为每个水壶上面装了一个开关，水烧开之后，水壶会自动通知我水烧开了

 

 

二、进程中的IO调用步骤大致可以分为以下四步：

1.进程向操作系统请求数据 ;

2.操作系统把外部数据加载到内核的缓冲区中;

3.操作系统把内核的缓冲区拷贝到进程的缓冲区 ;

4.进程获得数据完成自己的功能 ;

 

当操作系统在把外部数据放到进程缓冲区的这段时间（即上述的第二，三步），如果应用进程是挂起等待的，那么就是同步IO，反之，就是异步IO，也就是AIO 。

 

三、各自的特点

1）BIO（Blocking I/O）同步阻塞I/O 

    会阻塞每一个线程

 

    在高并发的web或者tcp服务器中采用BIO模型就无法应对了，如果系统开辟成千上万的线程，那么CPU的执行时机都会浪费在线程的切换中，使得线程的执行效率大大降低。

 

2）NIO (New I/O) 同步非阻塞I/O 

    只阻塞一个线程

 

NIO是New I/O的简称，与旧式的基于流的I/O方法相对，从名字看，它表示新的一套Java I/O标 准。它是在Java 1.4中被纳入到JDK中的，并具有以下特性:

– NIO是基于块(Block)的，它以块为基本单位处理数据

– 为所有的原始类型提供(Buffer)缓存支持

– 增加通道(Channel)对象，作为新的原始 I/O 抽象

– 支持锁和内存映射文件的文件访问接口

 – 提供了基于Selector的异步网络I/O

 

关于NIO弄清除 Channel、Buffer、Selector三个类之间的关系就可以了

 

Channel

首先说一下Channel，国内大多翻译成“通道”。Channel和IO中的Stream(流)是差不多一个等级的。只不过Stream是单向的，譬如：InputStream, OutputStream。而Channel是双向的，既可以用来进行读操作，又可以用来进行写操作，NIO中的Channel的主要实现有：FileChannel、DatagramChannel、SocketChannel、ServerSocketChannel；通过看名字就可以猜出个所以然来：分别可以对应文件IO、UDP和TCP（Server和Client）。

 

Buffer

NIO中的关键Buffer实现有：ByteBuffer、CharBuffer、DoubleBuffer、 FloatBuffer、IntBuffer、 LongBuffer,、ShortBuffer，分别对应基本数据类型: byte、char、double、 float、int、 long、 short。

 

Selector

Selector 是NIO相对于BIO实现多路复用的基础，Selector 运行单线程处理多个 Channel，如果你的应用打开了多个通道，但每个连接的流量都很低，使用 Selector 就会很方便。例如在一个聊天服务器中。要使用 Selector , 得向 Selector 注册 Channel，然后调用它的 select() 方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就可以处理这些事件，事件的例子有如新的连接进来、数据接收等。

 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 import java.nio.channels.ServerSocketChannel;
 import java.util.Iterator;

 public class TCPServerSelector{
     //缓冲区的长度
     private static final int BUFSIZE = 256;
     //select方法等待信道准备好的最长时间
     private static final int TIMEOUT = 3000;
     public static void main(String[] args) throws IOException {
         if (args.length < 1){
             throw new IllegalArgumentException("Parameter(s): <Port> ...");
         }
         //创建一个选择器
         Selector selector = Selector.open();
         for (String arg : args){
             //实例化一个信道
             ServerSocketChannel listnChannel = ServerSocketChannel.open();
             //将该信道绑定到指定端口
             listnChannel.socket().bind(new InetSocketAddress(Integer.parseInt(arg)));
             //配置信道为非阻塞模式
             listnChannel.configureBlocking(false);
             //将选择器注册到各个信道
             listnChannel.register(selector, SelectionKey.OP_ACCEPT);
         }
         //创建一个实现了协议接口的对象
         TCPProtocol protocol = new EchoSelectorProtocol(BUFSIZE);
         //不断轮询select方法，获取准备好的信道所关联的Key集
         while (true){
             //一直等待,直至有信道准备好了I/O操作
             if (selector.select(TIMEOUT) == 0){
                 //在等待信道准备的同时，也可以异步地执行其他任务，
                 //这里只是简单地打印"."
                 System.out.print(".");
                 continue;
             }
             //获取准备好的信道所关联的Key集合的iterator实例
             Iterator<SelectionKey> keyIter = selector.selectedKeys().iterator();
             //循环取得集合中的每个键值
             while (keyIter.hasNext()){
                 SelectionKey key = keyIter.next();
                 //如果服务端信道感兴趣的I/O操作为accept
                 if (key.isAcceptable()){
                     protocol.handleAccept(key);
                 }
                 //如果客户端信道感兴趣的I/O操作为read
                 if (key.isReadable()){
                     protocol.handleRead(key);
                 }
                 //如果该键值有效，并且其对应的客户端信道感兴趣的I/O操作为write
                 if (key.isValid() && key.isWritable()) {
                     protocol.handleWrite(key);
                 }
                 //这里需要手动从键集中移除当前的key
                 keyIter.remove();
             }
         }
     }
 }

 

3）AIO (Asynchronous I/O) 异步非阻塞I/O 

    不阻塞任何线程

 

• 读完了再通知我
• 不会加快IO，只是在读完后进行通知
• 使用回调函数，进行业务处理

 

 

 public static void main(String[] args) throws IOException {

     AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(0000));
     server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
         final ByteBuffer buffer = ByteBuffer.allocate(1024);

         @Override
         public void completed(AsynchronousSocketChannel result, Object attachment) {
             System.out.println(Thread.currentThread().getName());
             Future<Integer> writeResult = null;
             try {
                 buffer.clear();
                 result.read(buffer).get(100, TimeUnit.SECONDS);
                 buffer.flip();
                 writeResult = result.write(buffer);
             } catch (InterruptedException | ExecutionException e) {
                 e.printStackTrace();
             } catch (TimeoutException e) {
                 e.printStackTrace();
             } finally {
                 try {
                     server.accept(null, this);
                     writeResult.get();
                     result.close();
                 } catch (Exception e) {
                     System.out.println(e.toString());
                 }
             }
         }

         @Override
         public void failed(Throwable exc, Object attachment) {
             System.out.println("failed: " + exc);
         }
     });

 }