java之IO模型(BIO NIO AIO)

1.基本概念

BIO: Blocking IO，阻塞式IO，线程发起io请求后，一直阻塞(阻塞io)，直到数据就绪后，用户线程将数据写入socket空间，或从socket空间读取数据（同步）

NIO: Non-blocking IO，非阻塞式IO，需要用户线程定时轮训，去检查IO数据是否就绪，占用应用程序线程资源。IO多路复用模型中，将检查IO数据是否就绪的任务，交给系统级别的select或poll模型，由系统进行监控，减轻用户线程负担。

AIO: Asouync IO，异步IO，线程发起io请求后，立即返回（非阻塞io），当数据读写完成后，OS通知用户线程（异步）。这里数据写入socket空间，或从socket空间读取数据到用户空间由OS完成，用户线程无需介入，所以也就不会阻塞用户线程，即异步。AIO基于时间驱动思想，采用proactor模式。数据完成后，由os主动通知应用程序，通过epoll实现，节省了NIO中selector循环遍历检测数据就绪的资源开销。同时，数据copy操作（用户空间<->socket空间）是由os完成的，无需应用程序参与，大大提高应用程序效率。

2.优缺点

查了一些资料，都是用网络编程为例来说明BIO、NIO、AIO的区别，这里就不再敲代码了，直接说说彼此的优缺点好了。

BIO：优点是编码简单，容易上手、调试。缺点则是因为多线程本身的问题，①每个线程都要分配内存空间（最少128K），②线程的切换需要耗费时间。所以，一是线程数量有限；二是线程多了会严重降低响应时间。当然也可以使用线程池，但又涉及到队列任务积压问题。

NIO：刚好跟BIO相反。优点是速度快，耗费资源少。缺点是编码复杂，难以上手、调试。

AIO：事件驱动（回调），性能高。

话不多说，上代码：

BIO 客户端：    

public class BIOClient {
    public static void main(String[] args) throws Exception {
        Socket client = new Socket(HostInfo.HOST_NAME,HostInfo.PORT) ;  // 定义连接的主机信息
        Scanner scan = new Scanner(client.getInputStream()) ;   // 获取服务器端的响应数据
        scan.useDelimiter("\n") ;
        PrintStream out = new PrintStream(client.getOutputStream()) ; // 向服务器端发送信息内容
        boolean flag = true ; // 交互的标记
        while(flag) {
            String inputData = InputUtils.getInputString("请输入要发送的内容：").trim() ;
            out.println("【客户端】："+inputData); // 把数据发送到服务器端上
            if(scan.hasNext()) {
                String str = scan.next().trim() ;
                System.out.println(str);
            }
            if ("byebye".equalsIgnoreCase(inputData)) {
                flag = false ;
            }
        }
        client.close();
    }
}

BIO 服务端：

public class BIOServer {
    public static void main(String[] args) throws Exception{
        ServerSocket serverSocket = new ServerSocket(HostInfo.PORT) ;// 设置监听端口
        System.out.println("服务器端已经启动，监听的端口为：" + HostInfo.PORT);
        boolean flag = true ;
        ExecutorService executorService = Executors.newFixedThreadPool(10) ;
        while(flag) {
            Socket client = serverSocket.accept() ;
            executorService.submit(new EchoClientHandler(client)) ;
        }
        executorService.shutdown() ;
        serverSocket.close() ;
    }

    private static class EchoClientHandler implements Runnable {
        private Socket client ; // 每一个客户端都需要启动一个任务(task)来执行。
        private Scanner scanner ;
        private PrintStream out ;
        private boolean flag = true ;   // 循环标记
        public EchoClientHandler(Socket client) {
            this.client = client ; // 保存每一个客户端操作
            try {
                this.scanner = new Scanner(this.client.getInputStream()) ;
                this.scanner.useDelimiter("\n") ; // 设置换行符
                this.out = new PrintStream(this.client.getOutputStream()) ;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        public void run() {
            while(this.flag) {
                if (this.scanner.hasNext()) {   // 现在有数据进行输入
                    String val = this.scanner.next().trim() ; // 去掉多余的空格内容
                    System.err.println(val);
                    if("byebye".equalsIgnoreCase(val)) {
                        this.out.println("ByeByeByte...");
                        this.flag = false ;
                    } else {
                        String inputData = InputUtils.getInputString("请输入要发送的内容：").trim() ;
                        out.println("【服务端】" + inputData);
                    }
                }
            }
            this.scanner.close();
            this.out.close();
            try {
                this.client.close();
            } catch (IOException e) {
            }
        }
    }
}

注：通过开启线程池的方式，管理服务端，实现伪异步

NIO 客户端：

public class NIOEchoClient {
    public static void main(String[] args) throws Exception {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress(HostInfo.HOST_NAME,HostInfo.PORT));
        ByteBuffer buffer = ByteBuffer.allocate(50);
        boolean flag = true;
        while (flag) {
            buffer.clear();
            String inputString = InputUtils.getInputString("请输入要发送的内容：");
            buffer.put(inputString.getBytes());
            buffer.flip();
            socketChannel.write(buffer);

            //读取数据前清除缓存
            buffer.clear();
            int readCount = socketChannel.read(buffer);
            buffer.flip();
            System.out.println(new String(buffer.array(),0,readCount));
            if ("byebye".equals(inputString)) {
                flag = false;
            }
        }
        socketChannel.close();
    }
}

NIO 服务端：

public class NIOServer {
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(50);
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //设置模式为非阻塞
        serverSocketChannel.configureBlocking(false);
        //绑定一个网络服务端口
        serverSocketChannel.bind(new InetSocketAddress(HostInfo.PORT));

        //设置一个多路复用器，来作为一个选择器出现，目的是管理所有的channel
        Selector selector = Selector.open();
        //将所有的channel注册到selector
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务器已经启动，监听端口为：" + HostInfo.PORT);
        //NIO用的是轮询模式，每当发现有客户端连接时，开启一个线程，由线程池管理
        int keySelector = 0;
        while ((keySelector  = selector.select()) > 0) {
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = keys.iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                if(key.isAcceptable()){
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    if (socketChannel != null) {
                        executorService.execute(new NIOEchoHandler(socketChannel));
                    }
                }
            }
        }
    }

    private static class NIOEchoHandler implements Runnable {
        private SocketChannel socketChannel;
        private boolean flag = true;
        public NIOEchoHandler(SocketChannel socketChannel) {
            this.socketChannel = socketChannel;
        }

        @SneakyThrows
        @Override
        public void run() {
            ByteBuffer buffer = ByteBuffer.allocate(50);
            while (this.flag) {
                buffer.clear();
                try {
                    int readCount = this.socketChannel.read(buffer);
                    String readMessage = new String(buffer.array(), 0, readCount).trim();
                    System.out.println("【客户端】：" + readMessage);
                    String writeMessage = "【Echo】:" + readMessage + "\n";
                    if ("byebye".equals(readMessage)) {
                        writeMessage = "【Exit】:拜拜，下次见!";
                        this.flag = false;
                    }
                    buffer.clear();
                    buffer.put(writeMessage.getBytes());
                    buffer.flip();
                    this.socketChannel.write(buffer);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            this.socketChannel.close();
        }
    }
}

AIO 客户端：

class ClientReadHandler implements CompletionHandler<Integer,ByteBuffer> {
    private AsynchronousSocketChannel clientChannel ;
    private CountDownLatch latch ;
    public ClientReadHandler(AsynchronousSocketChannel clientChannel,CountDownLatch latch) {
        this.clientChannel = clientChannel ;
        this.latch = latch ;
    }
    @Override
    public void completed(Integer result, ByteBuffer buffer) {
        buffer.flip() ;
        String readMessage = new String(buffer.array(),0,buffer.remaining()) ;
        System.out.println(readMessage); // 输出读取内容
    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {
        try {
            this.clientChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        this.latch.countDown();
    }
}

class ClientWriteHandler implements CompletionHandler<Integer,ByteBuffer> {
    private AsynchronousSocketChannel clientChannel ;
    private CountDownLatch latch ;
    public ClientWriteHandler(AsynchronousSocketChannel clientChannel,CountDownLatch latch) {
        this.clientChannel = clientChannel ;
        this.latch = latch ;
    }

    @Override
    public void completed(Integer result, ByteBuffer buffer) {
        if(buffer.hasRemaining()) {
            this.clientChannel.write(buffer,buffer,this);
        } else {
            ByteBuffer readBuffer = ByteBuffer.allocate(100) ; // 读取服务端回应
            this.clientChannel.read(readBuffer,readBuffer,new ClientReadHandler(this.clientChannel,this.latch)) ;
        }
    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {
        try {
            this.clientChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        this.latch.countDown();
    }
}

class AIOClientThread implements Runnable {
    private AsynchronousSocketChannel clientChannel;
    private CountDownLatch latch;

    public AIOClientThread() {
        try {
            this.clientChannel = AsynchronousSocketChannel.open();
        } catch (IOException e) {
            e.printStackTrace();
        }
        this.clientChannel.connect(new InetSocketAddress(HostInfo.HOST_NAME, HostInfo.PORT));
        this.latch = new CountDownLatch(1);
    }

    @Override
    public void run() {
        try {
            this.latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public boolean sendMessage(String msg) {
        ByteBuffer buffer = ByteBuffer.allocate(100) ;
        buffer.put(msg.getBytes()) ;
        buffer.flip() ;
        this.clientChannel.write(buffer,buffer,new ClientWriteHandler(this.clientChannel,this.latch));
        if("byebye".equalsIgnoreCase(msg)) {
            return false ;
        }
        return true ;
    }
}

public class AIOEchoClient {
    public static void main(String[] args) {
        AIOClientThread client = new AIOClientThread() ;
        new Thread(client).start();
        while(client.sendMessage(InputUtils.getInputString("请输入要发送的内容："))) {
            ;
        }
    }
}

AIO 服务端：

public class AIOEchoServer {
    public static void main(String[] args) {
        new Thread(new AIOServerThread()).start();
    }
}

class AIOServerThread implements Runnable{
    private AsynchronousServerSocketChannel serverSocketChannel;
    private CountDownLatch latch;
    public AIOServerThread(){
        try {
            this.serverSocketChannel = AsynchronousServerSocketChannel.open();
            this.latch = new CountDownLatch(1);
            this.serverSocketChannel.bind(new InetSocketAddress(HostInfo.HOST_NAME,HostInfo.PORT));
            System.out.println("服务器启动成功，在" + HostInfo.PORT + "端口上监听服务 ...");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public AsynchronousServerSocketChannel getChannel(){
        return this.serverSocketChannel;
    }
    public CountDownLatch getLatch(){
        return this.latch;
    }



    @Override
    public void run() {
        this.serverSocketChannel.accept(this,new AcceptHandler());
        try {
            this.latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private class AcceptHandler implements CompletionHandler<AsynchronousSocketChannel, AIOServerThread> {

        @Override
        public void completed(AsynchronousSocketChannel result, AIOServerThread attachment) {
            attachment.getChannel().accept(attachment,this);
            ByteBuffer buffer = ByteBuffer.allocate(50);
            result.read(buffer,buffer,new EchoHandler(result));
        }

        @Override
        public void failed(Throwable exc, AIOServerThread attachment) {
            System.out.println("服务器端客户端连接失败 ...");
            attachment.getLatch().countDown();
        }
    }
}

public class EchoHandler implements CompletionHandler<Integer, ByteBuffer> {
    private AsynchronousSocketChannel clientChannel;
    private boolean exit = false;
    public EchoHandler(AsynchronousSocketChannel clientChannel) {
        this.clientChannel = clientChannel;
    }

    @Override
    public void completed(Integer result, ByteBuffer buffer) {
        buffer.flip();
        String reasMessage = new String(buffer.array(), 0, buffer.remaining());
        String writeMessage = "【Echo】:" + reasMessage + "\n";
        if ("byebye".equals(reasMessage)) {
            writeMessage = "【Exit】拜拜，下次见";
            this.exit = true;
        }
        this.writeMessage(writeMessage);
    }

    private void writeMessage(String writeMessage) {
        final ByteBuffer buffer = ByteBuffer.allocate(50);
        buffer.put(writeMessage.getBytes());
        buffer.flip();
        this.clientChannel.write(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer buf) {
                if(buf.hasRemaining()){
                    EchoHandler.this.clientChannel.write(buffer,buffer,this);
                }else {
                    if (EchoHandler.this.exit == false) {
                        ByteBuffer readerBuffer = ByteBuffer.allocate(50);
                        EchoHandler.this.clientChannel.write(readerBuffer,readerBuffer,new EchoHandler(EchoHandler.this.clientChannel));
                    }
                }
            }

            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                try {
                    EchoHandler.this.clientChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    @Override
    public void failed(Throwable exc, ByteBuffer buffer) {
        try {
            EchoHandler.this.clientChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}