java高级开发 - NIO

一、知识回顾

java IO模型有几种？

BIO 即(blocking)同步阻塞IO、NIO 同步非阻塞（non-blocking）IO、AIO 异步非阻塞IO(jdk7推出，可以说是NIO 2.0版)

1.理解什么是阻塞、非阻塞、同步、异步

举个简单的例子，我想喝热水，在家拿水壶烧水。

　一开始我比较笨，拿个水壶装上水放到炉子上等着水烧开（同步），在烧水过程中不做任何其他事情（阻塞）；

　然后我发现这也太无聊了，还是在等着水烧开(这时候还是同步)的时候干点别的吧，打开手机，玩一把游戏，中途时不时地去看一下水是否烧开了（非阻塞）；

　想着这样还是效率低下，然后我去买了个带响铃的水壶，只要水一烧开就发出响声通知我（异步），这下省心多了；

　下次用这个带响铃的来烧水(异步)， 我可以继续等着水开而不做其他事情(阻塞) 或者直接自己一边玩去了，水壶响了再去处理（非阻塞）；　

同步/异步关注的是消息如何通知，在上面的例子就是两种不同的通知方式：同步通知方式是人一直等消息，异步通知方式是由铃声报警器发送消息来通知人，人无需一直去查看消息。阻塞/非阻塞关注的是等待消息通知时的状态，阻塞的时候人的状态不变一直等着，非阻塞的时候人可以变成其他非等待状态，如玩游戏、看书等。

2.阻塞对服务端有什么影响

资源浪费、处理能力低下。

来一段BIO的socket通信代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * socket server 端
 *
 * @author gaojc
 * @date 2019/8/20 21:58
 */
public class BIOServer {
    public static int port = 8880;

    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(port);

            System.out.println("启动服务端，监听" + port + "端口");
            while (true) {
                try {
                    Socket accept = serverSocket.accept();
                    InputStream inputStream = accept.getInputStream();
                    BufferedReader bf = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));

                    String line = null;
                    while ((line = bf.readLine()) != null) {
                        System.out.println("服务端收到消息:" + line);
                    }
                    accept.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;

/**
 * Socket  client 端
 * 写1个socket通信，客户端向服务端发送数据，服务端打印出来
 *
 * @author gaojc
 * @date 2019/8/20 22:01
 */
public class BIOClient implements Runnable {
    String ip;
    int port;

    public BIOClient(String ip, int port) {
        this.ip = ip;
        this.port = port;
    }

    public static void main(String[] args) {
        BIOClient bioClient = new BIOClient("127.0.0.1", 8880);
        new Thread(bioClient).start();
        System.out.println("启动客户端，连接" + bioClient.port + "端口");
    }

    @Override
    public void run() {
        try {
            while (true) {
                Socket socket = new Socket(ip, port);
                Scanner scanner = new Scanner(System.in);
                System.out.println("客户端开始输入：");
                String nextLine = scanner.nextLine();

                socket.getOutputStream().write((nextLine).getBytes("UTF-8"));

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

服务端程序 通过while (true) 循环，阻塞的监听来自客户端的连接，阻塞的接收客户端发来的数据并输出。

为了不让接收客户端发来的数据这里阻塞，把服务端程序改造一下，使用多线程：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * socket server 端
 *
 * @author gaojc
 * @date 2019/8/20 21:58
 */
public class BIOServer {
    public static int port = 8880;

    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(port);

            System.out.println("启动服务端，监听" + port + "端口");
            while (true) {
                try {
                    Socket socket = serverSocket.accept();

                    //为每个连接 的读取数据 开 新的线程
                    new Thread(new ServerThread(socket)).start();

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

    }

    //把接收客户端数据的地方 搞多线程
    static class ServerThread implements Runnable {
        Socket socket;

        public ServerThread(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try {
                InputStream inputStream = socket.getInputStream();
                BufferedReader bf = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));

                String line = null;
                while ((line = bf.readLine()) != null) {
                    System.out.println("服务端收到消息:" + line);
                }
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

如果多线程并发请求过大，这样创建线程过多，线程栈需要系统内存，可能会造成OOM；

线程处理逻辑的代码还需要创建对象，消耗堆内存；

而且多线程使得CPU频繁切换，严重影响性能。

有没办法改进这些弊端？有，想到了线程池，那么来继续改造一下代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * socket server 端
 *
 * @author gaojc
 * @date 2019/8/20 21:58
 */
public class BIOServer {
    public static int port = 8880;

    public static void main(String[] args) {
        //复用线程，大大减少线程数量
        int threadNum = 2;

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(threadNum, threadNum,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>());

        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(port);

            System.out.println("启动服务端，监听" + port + "端口");
            while (true) {
                try {
                    Socket socket = serverSocket.accept();

                    //用线程池 读取每个连接的数据
                    threadPool.execute(new ServerThread(socket));

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

    //把接收客户端数据的地方 搞多线程
    static class ServerThread implements Runnable {
        Socket socket;

        public ServerThread(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try {
                InputStream inputStream = socket.getInputStream();
                BufferedReader bf = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));

                String line = null;
                while ((line = bf.readLine()) != null) {
                    System.out.println("服务端收到消息:" + line);
                }
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

服务端用线程池 来接收客户端的数据，不用为每次连接都创建线程，减少内存开销，节省线程创建的成本

那么这样还是有问题，阻塞对线程池的影响：

阻塞等待接收客户端的数据时，占用线程，而线程池的线程是有限的，并发量大的时候，会导致没有足够的线程来处理请求，请求的响应时间长，甚至拒绝服务。

那么如果能不阻塞，在没有接收到数据的时候去干别的事情，不就好了？

二、NIO 华丽登场

这时候 就需要用到NIO了，NIO可以以 non - blocking模式工作，可以用极少量线程处理大量IO连接。

NIO的工作原理图：

来改造socket服务端的代码，使用NIO

package com.gaojc.springboot.demo.servicefind.IO;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * NIO socket server 端
 *
 * @author gaojc
 * @date 2019/8/22 21:58
 */
public class NIOSocketServer {
    public static int port = 8880;
    public static int threadNum = 2;

    public static void main(String[] args) {
        ByteBuffer readBuf = ByteBuffer.allocateDirect(1024);

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(threadNum, threadNum,
                10L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(100));
        //NIO多路选择器
        Selector selector;
        ServerSocketChannel serverSocketChannel = null;

        //连接计数
        int connectionCount = 0;

        try {
            //1.创建一个选择器
            selector = Selector.open();
            //2.打开服务器通道
            serverSocketChannel = ServerSocketChannel.open();

            //3、服务器通道绑定地址
            serverSocketChannel.bind(new InetSocketAddress(port));
            //4.设置为非阻塞
            serverSocketChannel.configureBlocking(false);
            //5.把服务器通道注册到selector选择器上，监听阻塞事件
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            System.out.println("启动服务端，监听" + port + "端口");

            //selector循环监听
            while (true) {
                //1.等待 就绪的事件
                int selectCount = selector.select();
                //没有就绪的事件就 continue
                if (selectCount == 0) {
                    continue;
                }

                //2.得到就绪的事件
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                //3.遍历结果
                Iterator<SelectionKey> iterator = selectionKeys.iterator();

                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    //如果是阻塞的状态
                    if (selectionKey.isAcceptable()) {
                        //获取服务器通道
                        ServerSocketChannel ssc = (ServerSocketChannel) selectionKey.channel();
                        SocketChannel sc = null;
                        try {
                            //1.调用服务器端的accpet方法获取客户端通道
                            sc = ssc.accept();
                            //2.设置为非阻塞
                            sc.configureBlocking(false);
                            //3.将客户端通道注册到selector中
                            sc.register(selector, SelectionKey.OP_READ, ++connectionCount);
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }

                    //如果是可读的状态了
                    if (selectionKey.isReadable()) {
                        //1.用线程池 读取通道的数据
                        threadPool.execute(new ServerThread(readBuf, selectionKey));
                        //2.取消注册，防止线程池处理不及时，重复选择
                        selectionKey.cancel();
                    }
                    //4.处理完了，一定要从迭代里remove
                    iterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        threadPool.shutdown();
    }

    //把接收客户端数据的地方 搞多线程
    static class ServerThread implements Runnable {
        ByteBuffer readBuf;
        SelectionKey selectionKey;

        public ServerThread(ByteBuffer readBuf, SelectionKey selectionKey) {
            this.readBuf = readBuf;
            this.selectionKey = selectionKey;
        }

        @Override
        public void run() {
            try {
                //1、先清空缓冲区，防止有上一次的读数据
                this.readBuf.clear();
                //2、获取客户端通道
                SocketChannel sc = (SocketChannel) selectionKey.channel();
                //3、看客户端是否有输入
                int count = sc.read(this.readBuf);
                if (count == -1) {//如果没有数据
                    selectionKey.cancel();
                    sc.close();
                }
                //4、把buffer转为读模式
                this.readBuf.flip();
                //5、根据缓冲区的数据长度创建对应大小的byte数组，接收缓冲区的数据
                byte[] data = new byte[this.readBuf.remaining()];
                //6、将数据从这个缓冲区传输到目标字节数组
                this.readBuf.get(data);
                //7、将byte数组内容打印出来
                String result = new String(data);
                System.out.println("接受到client的数据是:" + result);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

这样就使用了非阻塞的IO，使用了selector选择器，做到IO连接多路复用。