传统IO和NIO的实例比较

我们先通过一段代码来看看传统IO的特点：我们构建一个服务端，然后使用telnet进行客户端的连接测试。
这里要注意如果你的window没有安装telnet客户端的话，使用telnet命令是会报"telnet不是内部或外部命令"的。如下图：

image.png

解决方法：
   操作过程：点击"开始"→"控制器面板"→" 查看方式：类型"则点击"程序"（"查看方式：大图标"则点击"程序和功能"）→ "启动或关闭windows功能"→ 在"Windows功能"界面勾选Telnet服务器和客户端 →最后点击"确定"等待安装。勾选Telnet客户端如下图：

勾选Telnet客户端.png
操作成功之后会再次进入命令行输入telnet便会出现如下界面： telnet使用.png

好了，准备工作就做好了，现在开始上我们的代码了，用Java传统IO写个服务器端：

public class OioServer {

    public static void main(String[] args) {

        ServerSocket serverSocket = null;

        try {
            //创建一个Socket服务，监听10000端口
            serverSocket = new ServerSocket(10000);
            System.out.println("服务器启动...");
            while(true){
               final Socket socket = serverSocket.accept();
                System.out.println("来了一个新的客户端连接");
               handler(socket);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 服务handler
     */
    public static void handler(Socket socket){

        byte[] buffer = new byte[1024];
        InputStream inputStream = null;
        try {
            inputStream = socket.getInputStream();
            while(true){
                int read = inputStream.read(buffer);
                if(read!=-1){
                    System.out.println(new String(buffer,0,read));
                }
            }
        } catch (IOException e) {
            System.out.println("获取Socket的输入流失败！");
            e.printStackTrace();
        }
    }
}

启动这个main我们使用telnet方式模拟客户端来看看传统的IO有哪些特征：
运行结果：

image.png

首先很典型的就是启动的时候使用Dubug方式，我们发现线程堵塞在final Socket socket = serverSocket.accept()这一行，然后使用telnet连接之后，程序又堵塞在了handler方法的这一行int read = inputStream.read(buffer);，而且我们开了一个telnet客户端的情况下，如果再次开一个会发现，这个时候我们是无法在第一个telnet连接还没有断开的情况下开启第二个连接的。
所以综合上诉我们总结出了传统IO一下3个特征：

1.堵塞
2.单线程情况下只响应一个客户端连接的事件

现在我们在上面的代码上面做一些优化，就是解决传统IO只能连接一个客户端的问题，因为上面的代码连接不上实际上是因为我们把服务器的端口连接监听和监听处理都放到了一个线程去做，
而在第一个客户端没有关闭的情况下线程实际上堵塞在了第一个客户端的read这一行（我去监听第一个客户端去了），这个时候你开启第二个telnet来连接服务器，我们的请求当然是不会被搭理的咯。
所以我们将监听和监听处理分别交给两个不同的线程来做，这样的话，线程也不会忙不过来，看下面的代码：
我们使用线程池来解决单个客户端的问题：

public static void main(String[] args) {

        ExecutorService executorService = Executors.newCachedThreadPool();
        ServerSocket serverSocket = null;

        try {
            //创建一个Socket服务，监听10000端口
            serverSocket = new ServerSocket(10000);
            System.out.println("服务器启动...");
            while(true){
               final Socket socket = serverSocket.accept();
                System.out.println("来了一个新的客户端连接");
                executorService.submit(new Runnable() {
                    @Override
                    public void run() {
                        handler(socket);
                    }
                });

            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 服务handler
     */
    public static void handler(Socket socket){

        byte[] buffer = new byte[1024];
        InputStream inputStream = null;
        try {
            inputStream = socket.getInputStream();
            while(true){
                int read = inputStream.read(buffer);
                if(read!=-1){
                    System.out.println(new String(buffer,0,read));
                }
            }
        } catch (IOException e) {
            System.out.println("获取Socket的输入流失败！");
            e.printStackTrace();
        }
    }

运行结果：

image.png

思考:这就解决了我们之前的问题但是如果我这个服务器每秒有百万级别的人去访问呢？线程池就要开百万个线程去监听，这显然很不合理，至少传统IO在双十一这种高并发场景的瓶颈是很明显的。

总结: 传统IO就好比下图的这种模式:

image.png

一家餐厅，有一个大门（ServerSocket）然后每次来一个客人，我们就要聘用一个服务员进行服务，服务员没有得到复用，性能消耗巨大，这显然很不合理，如果来的客人多了，客人又没点多少才，估计餐厅老板得破产。我们现实中餐厅的服务员都是一个人给好几桌甚至好几十桌的人服务的。所以后来在传统IO的基础上，我们有了NIO（new IO),它和传统IO最大的区别就是它更加优雅，更加方便，更加符合生活。
NIO就是我们现实中饭店的模型。服务员可以为多个客户服务。

image.png

我们通过代码来实际验证这种特性：

/**
 * NIO服务端
 * 代码来源网络，再此感谢各位前辈。
 * @author -GuiRong
 */
public class NIOServer {
    // 通道管理器
    private Selector selector;

    /**
     * 获得一个ServerSocket通道，并对该通道做一些初始化的工作
     *
     * @param port 绑定的端口号
     * @throws IOException
     */
    public void initServer(int port) throws IOException {
        // 获得一个ServerSocket通道
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        // 设置通道为非阻塞
        serverChannel.configureBlocking(false);
        // 将该通道对应的ServerSocket绑定到port端口
        serverChannel.socket().bind(new InetSocketAddress(port));
        // 获得一个通道管理器
        this.selector = Selector.open();
        // 将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，
        // 当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    }

    /**
     * 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
     *
     * @throws IOException
     */
    public void listen() throws IOException {
        System.out.println("服务端启动成功！");
        // 轮询访问selector
        while (true) {
            // 当注册的事件到达时，方法返回；否则,该方法会一直阻塞
            selector.select();
            // 获得selector中选中的项的迭代器，选中的项为注册的事件
            Iterator<?> ite = this.selector.selectedKeys().iterator();
            while (ite.hasNext()) {
                SelectionKey key = (SelectionKey) ite.next();
                // 删除已选的key,以防重复处理
                ite.remove();
                
                handler(key);
            }
        }
    }

    /**
     * 处理请求
     *
     * @param key
     * @throws IOException
     */
    public void handler(SelectionKey key) throws IOException {

        // 客户端请求连接事件
        if (key.isAcceptable()) {
            handlerAccept(key);
            // 获得了可读的事件
        } else if (key.isReadable()) {
            handelerRead(key);
        }
    }

    /**
     * 处理连接请求
     *
     * @param key
     * @throws IOException
     */
    public void handlerAccept(SelectionKey key) throws IOException {
        ServerSocketChannel server = (ServerSocketChannel) key.channel();
        // 获得和客户端连接的通道
        SocketChannel channel = server.accept();
        // 设置成非阻塞
        channel.configureBlocking(false);

        // 在这里可以给客户端发送信息哦
        System.out.println("新的客户端连接");
        // 在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
        channel.register(this.selector, SelectionKey.OP_READ);
    }

    /**
     * 处理读的事件
     *
     * @param key
     * @throws IOException
     */
    public void handelerRead(SelectionKey key) throws IOException {
        // 服务器可读取消息:得到事件发生的Socket通道
        SocketChannel channel = (SocketChannel) key.channel();
        // 创建读取的缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int read = channel.read(buffer);
        if (read > 0) {
            byte[] data = buffer.array();
            String msg = new String(data).trim();
            System.out.println("服务端收到信息：" + msg);

            //回写数据
            ByteBuffer outBuffer = ByteBuffer.wrap("好的".getBytes());
            channel.write(outBuffer);// 将消息回送给客户端
        } else {
            System.out.println("客户端关闭");
            key.cancel();
        }
    }

    /**
     * 启动服务端测试
     *
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        NIOServer server = new NIOServer();
        server.initServer(8000);
        server.listen();
    }

}

运行结果：

image.png

---

NIO的一些疑问

1、客户端关闭的时候会抛出异常，死循环解决方案

  int read = channel.read(buffer);
    if(read > 0){
        byte[] data = buffer.array();
        String msg = new String(data).trim();
        System.out.println("服务端收到信息：" + msg);
        
        //回写数据
        ByteBuffer outBuffer = ByteBuffer.wrap("好的".getBytes());
        channel.write(outBuffer);// 将消息回送给客户端
    }else{
        System.out.println("客户端关闭");
        key.cancel();
    }

2、selector.select();阻塞，那为什么说nio是非阻塞的IO？

selector.select()
selector.select(1000);不阻塞
selector.wakeup();也可以唤醒selector
selector.selectNow();也可以立马返还，视频里忘了讲了，哈，这里补上

3、SelectionKey.OP_WRITE是代表什么意思

  OP_WRITE表示底层缓冲区是否有空间，是则响应返还true

附:项目下载地址
注:个人学习笔记，部分资源来源于网络。在此感谢各位前辈！