本文共 8788 字，大约阅读时间需要 29 分钟。

NIO编程一直是Java知识体系中的一个重点。前几年的时间面试的门槛是了解NIO,现在就不一样了,最起码也要精通NIO,因此学习javaNIO编程是非常有必要的。这篇文章就开始对NIO进行一个认识。本文参考了慕课网，特在此说明。

一、认识NIO

1、什么是BIO？

想要学习NIO，那我们就必须先要认识一下BIO，在JDK1,4之前，我们使用网络连接的时候一直都是使用的BIO，也就是阻塞式，网络模型是下面这个样子的。

上面这个网络模型是这样的。

（1）server创建初始化一些预备工作之后，就开始等待客户端client的链接

（2）client开始链接server。

（3）server一旦请求到client的请求之后就会开启一个线程去处理。

就好比是只有一家餐饮店，每进来一个顾客，我们就需要去创建一个线程去处理。这就是BIO。他的缺点可想而知。如果客户端很多的话，server就必须要开启很多个Thread去处理，这样也太麻烦了。毕竟像淘宝微信这样的平台好几亿人再用，而且请求量这么大，总不能开启几亿个线程去处理吧。这时候在jdk1.4就出现了NIO。

2、出现了NIO

既然BIO有这么多的缺点，java官方肯定也明白，于是在jdk1.4的时候及时的加入了NIO。

这个跟上一个的区别我们来捋一下：

（1）一个客户端进来之后首先加入到Set中

（2）server时刻轮询着这个set，一旦发现有客户端连接进来就开始handler

（3）多个client连接进来的时候，都保存在这个set中，这样我们就可以轮询处理多个client了。

这就NIO，他的优点从上面的图也可以看出来。我们可能只需要创建一个Thread就可以处理所有的client了。当然每一个client要做的事情不一样，有的是连接请求，有的是读写请求，这时候server就可以根据不同的请求使用不同的handler了。再给出一张图看一下：

当然，这只是列举出了NIO的特点，还有大致网络模型，想要去真正的了解他，还是代码来的直接。

二、代码实现

1、基本概念

在正式开始代码的编写之前，我们还要先认识一下涉及到的几个类。

（1）channel

它相当于是一个通道，这个通道是流通数据的，我们既可以从通道中读取数据，又可以写数据到通道。常见的channel有四个：FileChannel、DatagramChannel、SocketChannel、ServerSocketChannel。

• FileChannel 从文件中读写数据。

• DatagramChannel 能通过UDP读写网络中的数据。

• SocketChannel 能通过TCP读写网络中的数据。

• ServerSocketChannel可以监听新进来的TCP连接，像Web服务器那样。对每一个新进来的连接都会创建一个SocketChannel。

（2）Buffer

Buffer用于和通道进行交互。数据是从通道读入缓冲区，从缓冲区写入到通道中的。

使用Buffer读写数据一般遵循以下四个步骤：

1. 写入数据到Buffer
2. 调用flip()方法
3. 从Buffer中读取数据
4. 调用clear()方法或者compact()方法

（3）Selector

Selector（选择器）能够检测一到多个NIO通道，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接。

2、实现步骤

我们在这里实现一个类似于聊天室的案例，上面已经把NIO涉及到的一些核心类说了一下，下面说一下实现的步骤。这个步骤是要结合上面的图来理解会比较容易一些：

第一步：创建Selector

第二步：创建ServerSocketChannel，绑定监听端口

第三步：将Channel设置为非阻塞模式

第四步：将Channel注册到Selector上，监听连接事件

第五步：循环调用Selector的select方法，检测就绪情况

第六步：调用selectedKeys方法获取就绪channel集合

第七步：判断就绪事件种类，调用业务处理方法

第八步：根据业务需要决定是否再次注册监听事件，重复执行第三步操作

有了这个步骤我们再去代码实现。

3、代码实现

（1）server端代码开发

首先我们看一下服务器端

public class NioServer {
       public static void main(String[] args) throws IOException {
           new NioServer().start();    }    public void start() throws IOException {
           //第一步. 创建Selector        Selector selector = Selector.open();        //第二步：通过ServerSocketChannel创建channel通道        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();        //第三步：为channel通道绑定监听端口        serverSocketChannel.bind(new InetSocketAddress(8000));        //第四步：设置channel为非阻塞模式        serverSocketChannel.configureBlocking(false);        //第五步：将channel注册到selector上，监听连接事件        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);        System.out.println("服务器启动成功！");        //第六步：循环等待新接入的连接        for (;;) {
               // 获取可用channel数量            int readyChannels = selector.select();            if (readyChannels == 0) continue;            // 获取可用channel的集合            Set
   
     selectionKeys = selector.selectedKeys();            Iterator iterator = selectionKeys.iterator();            while (iterator.hasNext()) {
                   SelectionKey selectionKey = (SelectionKey) iterator.next();                iterator.remove();                //第七步：根据就绪状态，调用对应方法处理业务逻辑                //第一种情况：如果是链接事件，那就是使用链接Handler处理                if (selectionKey.isAcceptable()) {
                       acceptHandler(serverSocketChannel, selector);                }				//第二种情况：如果是读写事件，那就是使用读写Handler处理                if (selectionKey.isReadable()) {
                       readHandler(selectionKey, selector);                }            }        }    }}
   

上面把server中基本的是步骤实现了。现在开始真正的去处理一下。

第一种情况：链接事件处理

private void acceptHandler(ServerSocketChannel serverSocketChannel,    Selector selector) throws IOException {
           //第一步：创建socketChannel        SocketChannel socketChannel = serverSocketChannel.accept();        //第二步：将socketChannel设置为非阻塞工作模式        socketChannel.configureBlocking(false);        //第三步：将channel注册到selector上，监听 可读事件        socketChannel.register(selector, SelectionKey.OP_READ);        //第四步：回复客户端提示信息        socketChannel.write("您已连接成功");    }

第二种情况：读写时间处理

private void readHandler(SelectionKey selectionKey, 	Selector selector) throws IOException {
       //第一步：要从 selectionKey 中获取到已经就绪的channel    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();    //第二步：创建buffer    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);    //第三步：循环读取客户端请求信息    String result = "";    while (socketChannel.read(byteBuffer) > 0) {
             //切换buffer为读模式          byteBuffer.flip();          //读取buffer中的内容          result += Charset.forName("UTF-8").decode(byteBuffer);    }    //第四步：将channel再次注册到selector上，监听他的可读事件    socketChannel.register(selector, SelectionKey.OP_READ);    //第五步：将客户端发送的请求信息 广播给其他客户端    if (request.length() > 0) {
             // 广播给其他客户端          broadCast(selector, socketChannel, result);    }}

到了第五步broadCast方法其实我们可以对此进行一个变化，在这里我们实现的是广播到其他所有client。但是如果是一对一聊天的话我们就可以单播到指定client。

private void broadCast(Selector selector,    SocketChannel sourceChannel, String request) {
        //第一步：获取到所有已接入的客户端channel     Set
   
     selectionKeySet = selector.keys();     //第三步：循环向所有channel广播信息     selectionKeySet.forEach(selectionKey -> {
            Channel targetChannel = selectionKey.channel();         // 剔除自己：自己不能给自己发信息         if (targetChannel instanceof SocketChannel                && targetChannel != sourceChannel) {
                try {
                     // 将信息发送到targetChannel客户端                 ((SocketChannel) targetChannel).write(request);             } catch (IOException e) {
                    e.printStackTrace();             }         }    });}
   

这就是整个服务器端的开发，当然还要客户端的开发，我们同样来看看。

（2）client端代码开发

客户端代码说实话就比较轻松一点了。

public class NioClient {
       public static void main(String[] args) throws IOException {
           new NioClient().start();    }    public void start(String nickname) throws IOException {
           //第一步：连接服务器端        SocketChannel socketChannel = SocketChannel.open(                new InetSocketAddress("170.153.0.53", 8000));        //第二步：新建selector        Selector selector = Selector.open();        //第三步：socketChannel设置为非阻塞        socketChannel.configureBlocking(false);        //第四步：注册通道到selector上        socketChannel.register(selector, SelectionKey.OP_READ);        //第五步：处理数据        //第一种情况：处理服务器返回的数据        new Thread(new NioClientHandler(selector)).start();        //第二种情况：向服务器发送数据        String request = "我是java的架构师技术栈，大家好";        if (request != null && request.length() > 0) {
                socketChannel.write(request);       }    }}

我们就再来看看，客户端如何处理服务器端返回的数据。

public class NioClientHandler implements Runnable {
       private Selector selector;    public NioClientHandler(Selector selector) {
           this.selector = selector;    }	//在run方法中处理    @Override    public void run() {
           try {
               for (;;) {
                   //第一步：获取到当前的channel                int readyChannels = selector.select();                if (readyChannels == 0) continue;                //第二步：获取可用channel的集合                Set
   
     selectionKeys = selector.selectedKeys();                Iterator iterator = selectionKeys.iterator();                while (iterator.hasNext()) {
                       SelectionKey selectionKey = (SelectionKey) iterator.next();                    iterator.remove();					//第三步：使用readHandler读取数据                    if (selectionKey.isReadable()) {
                           readHandler(selectionKey, selector);                    }                }            }        } catch (IOException e) {
               e.printStackTrace();        }    }}
   

readHandler方法是如何读取呢？

private void readHandler(SelectionKey selectionKey,      Selector selector) throws IOException {
         //第一步：要从 selectionKey 中获取到已经就绪的channel     SocketChannel socketChannel = (SocketChannel) selectionKey.channel();      //第二步：创建buffer     ByteBuffer byteBuffer = ByteBuffer.allocate(1024);      //第三步：循环读取服务器端响应信息      String response = "";      while (socketChannel.read(byteBuffer) > 0) {
               byteBuffer.flip();            response += Charset.forName("UTF-8").decode(byteBuffer);      }      //第三步：将channel再次注册到selector上，监听他的可读事件      socketChannel.register(selector, SelectionKey.OP_READ);      //第四步：将服务器端响应信息打印到本地      if (response.length() > 0) {
             System.out.println(response);      }}

到这一步，整个客户端的代码就算是完成了，如果你仔细的捋一遍，其实整个流程还是很清晰的。

三、总结

虽然NIO这么好其实还是有很多缺点的，在上面的代码量其实你就可以发现了，大量的代码使得我们在构建复杂系统的时候超级麻烦，有时候正是这些技术的不完备，才造成了我们程序员工作量大，压力大，但是科技的进步毕竟是要一点一点发展的嘛。另外说一句这个NIO还有一个大坑，就是Selector空轮询的时候，导师CPU100%。不过这种情况我还没试过。

esponse.length() > 0) {

System.out.println(response); } } ``

到这一步，整个客户端的代码就算是完成了，如果你仔细的捋一遍，其实整个流程还是很清晰的。

三、总结

虽然NIO这么好其实还是有很多缺点的，在上面的代码量其实你就可以发现了，大量的代码使得我们在构建复杂系统的时候超级麻烦，有时候正是这些技术的不完备，才造成了我们程序员工作量大，压力大，但是科技的进步毕竟是要一点一点发展的嘛。另外说一句这个NIO还有一个大坑，就是Selector空轮询的时候，导师CPU100%。不过这种情况我还没试过。

想要精通NIO的话，这篇文章真的远远不够，顶多算是入门把。想要真正认识我觉得首先要深入源码，然后就是实际场景中的使用，不过目前来看的话netty和mina框架要比java的NIO好的多，不单单是性能，更重要的是我们的开发效率。算是在一定程度上避免了我们程序员“钱多话少死得快”的现象了吧。

转载地址：http://fnbdi.baihongyu.com/