理解BIO与NIO

1.我们理解中BIO是什么？
在jdk1.4之前的IO称之为BIO（Blocking IO）,同步阻塞IO。原始的IO有文件流和网络流。
下面是网络流对应的示例代码：

public static void main(String[] args) {
        server1();
    }

    private static void server1() {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream in = null;
        OutputStream out = null;
        try {
            serverSocket = new ServerSocket(8000);
            System.out.println(">>> 服务端启动成功,监听端口8000，等待客户端连接中...");
            //阻塞
            socket = serverSocket.accept();
            in = socket.getInputStream();
            byte[] buffer = new byte[1024];
            int len = 0;
            //读取客户端的数据
            while ((len = in.read(buffer)) > 0) {
                System.out.println(new String(buffer, 0, len));
            }
            //向客户端写数据
            out = socket.getOutputStream();
            out.write("已收到你的数据".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

单线程的情况下，如果读写操作并没有完成，那么当前线程是不能进行其他操作的。
在高并发情况下，这种效率是最低的，显然不满足要求。
那么使用线程池中的线程去执行每个对应的任务：

private static void server2() {
        ServerSocket serverSocket = null;
        Socket socket = null;
        ExecutorService executorService = Executors.newFixedThreadPool(60);
        try {
            serverSocket = new ServerSocket(8000);
            System.out.println(">>> 服务端启动成功,监听端口8000，等待客户端连接中...");
            while (true) {
                socket = serverSocket.accept();
                //使用线程池中的线程去执行每个对应的任务
                executorService.execute(new ServerHandler(socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

这样大大的提高了服务端的效率，但是还是需要创建许多线程的。当请求太多的情况下，就会出现排队问题，
等待超时问题。显然这不是最优的解决方案。

2.New IO
Non-Blocking 非阻塞的IO
阻塞：单线程的情况下，当前IO操作没有完成的话，会一直阻塞，当前线程不能做其他事情。
非阻塞：单线程情况下，当前的IO操作即使没有完成，当前线程也可以做其他事情。

其实，仔细分析一下，核心的操作在于IO，不是IO就不会创建线程的，那么，不妨对socket做个登记，
需要进行IO操作的再创建线程，这样可以间接的减少
服务端线程的数量。

public class NioServer {

    //选择器
    private Selector selector = null;

    public NioServer(int port) {
        InetSocketAddress inetSocketAddress = new InetSocketAddress(port);
        try {
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.socket().bind(inetSocketAddress);
            //服务器通道设置成非阻塞模式
            serverSocketChannel.configureBlocking(false);
            selector = Selector.open();
            //每当有客户端连接上来的时候，默认它已经连接上来了
            //而这个连接我需要记录一下它的状态 Connected
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println(">>> 服务端启动成功，端口:" + port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Selector开始轮询
     */
    public void listen() {
        try {
            while (true) {
                //accept是阻塞的，select也是阻塞的
                int wait = this.selector.select();
                if (wait == 0) {
                    continue;
                }
                //SelectionKey代表的是客户端和服务端连接的一个关键
                Set<SelectionKey> selectionKeys = this.selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    //针对每一个客户端进行相应的操作
                    process(iterator.next());
                    iterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 处理每一个客户端
     */
    private void process(SelectionKey key) throws IOException {
        if (key.isAcceptable()) {
            ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
            SocketChannel socketChannel = serverSocketChannel.accept();
            socketChannel.configureBlocking(false);
            //客户端一旦连接上来
            //往selector注册key
            socketChannel.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            //中间的数据交流桥梁
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            SocketChannel socketChannel = (SocketChannel) key.channel();
            //把数据读取到buffer中
            int len = socketChannel.read(buffer);
            //读取完成了
            if (len > 0) {
                //固定
                buffer.flip();
                String content = new String(buffer.array(), 0, len);
                socketChannel.register(selector, SelectionKey.OP_WRITE);
                System.out.println(content);
            }
            buffer.clear();
        } else if (key.isWritable()) {
            SocketChannel socketChannel = (SocketChannel) key.channel();
            socketChannel.write(ByteBuffer.wrap("写数据".getBytes()));
            socketChannel.close();
        }
    }

    public static void main(String[] args) {
        new NioServer(8000).listen();
    }