使用NIO实现非阻塞Socket通信

前言

从JDK1.4以来，Java提供了NIO API来开发高性能的网络服务，但是在JDK1.4之前，网络通信程序是基于阻塞式API的——即当程序执行输入，输出操作后，在这些操作返回之前会一直阻塞该线程，所以服务器必须为每个客户端都提供一个独立线程进行处理，当服务器端需要同时处理大量客户端时，这种做法会导致性能下降。使用NIO API则可以让服务器端使用一个或有限几个线程来同时处理链接到服务器端的所有程序。

Java NIO为非阻塞式Socket通信提供了如下几个方法

一定要认真看，不然后续讲的代码就看不懂了，也可以结合后续代码一起来看！

1.Selector:它是SelectableChannel对象的多路复用器，所有希望采用非阻塞方式进行通信的Channel都应该注册到Selector对象。可以通过调用此类的open()静态方法来创建Selector实例，该方法将使用系统默认的Selector来返回新的Selector.

2.Selector可以同时监控多个SelectableChannel的IO状态，是非阻塞IO的核心。一个Selector实例有三个SelectionKey集合。
1).所有的SelectionKey集合：代表了注册在该Selector上的Channel,这个集合可以通过keys()方法返回。
2).被选择的SelectionKey集合：代表了所有可通过select()方法获取的，需要进行IO处理的Channel，这个集合可以通过selectedKeys()返回。
3).被取消的SelectionKey集合：代表了所有被取消注册关系的Channel,在下一次执行select()方法时，这些Channel对应的SelectionKey会被彻底解除，程序通常无需直接访问该集合。

3.除此之外，Selector还提供了一系列和select()相关的方法，如下所示。
1).int select():监控所有注册的Channel,当他们中间有需要处理的IO操作时，该方法返回，并将对应的SelectionKey加入到被选择的SelectionKey集合中，该方法返回这些Channel的数量。
2).int select(long timeout):可以设置超时时长的select()操作。
3).int selectNow():执行一个立即返回的select()操作，相对于无参数的select()方法而言，该方法不会阻塞线程。

4.Selector wakeuo():使一个还未返回的select()方法立返回。

5.SelectableChannel:它代表可以支持非阻塞IO操作的Channel对象，它可被注册到Selector上，这种注册关系由SelectionKey实例表示。Selector对象提供了一个select()方法，该方法允许应用程序同时监控多个IO Channel。

6.应用程序可调用SelectableChannel的register()方法将其注册到指定Selector上，当该Selector上的某些SelectableChannel上有需要处理的IO操作时，程序可以调用Selector实例的select()方法获取它们的数量，并可以通过selectredKeys()方法返回它们对应的SelectionKey集合——通过该集合就可以获取所有需要进行IO处理的SelectableChannel集。

7.SelectableChannel对象支持阻塞和非阻塞两种模式(所有的Channel默认都是阻塞模式)，必须使用非阻塞模式才可以利用非阻塞IO操作。SelectableChannel提供了如下两个方法来设置和返回该Channel的模式状态。
1).SelectableChannel configureBloking(boolean blok):设置所否采用阻塞模式。
2).boolean isBlocking():返回该Channel是否是阻塞模式。

8.不同的SelectableChannel所支持的操作不一样。例如ServerSocketChannel代表一个ServerSocket，它就只支持OP_ACCEPT操作SelectableChannel提供了如下方法返回它支持的左右操作。

int validOps():返回一个整数值，表示这个Channel所支持的IO操作。

9.除此之外，SelectableChannel还提供了如下几个方法来获取它的注册状态。
1).boolean isRegistered():返回该Channel是否已注册在一个或多个Selector上。
2).SelectionKey keyFor(Selector sel):返回该Channel和sel Selector之间的注册关系，如果不存在注册关系，则返回null.
3).ServerSocketChannel:支持非阻塞操作，对应于java.net.ServerSocket这个类，只支持OP_ACCEPT操作。该类也提供了accept()方法，功能相当于ServerSocket提供的accept()方法。
4).SocketChannel：支持非阻塞操作，对应于java.net.Socket这个类，支持OP_CONNECT,OP_READ和OP_WRITE操作。这个类还实现了ByteChannel接口，ScatteringByteChannel接口和GatheringByteChannel接口，所以可以直接通过SocketChannel来读写ByteBuffer对象。

NIO的非阻塞式服务器示意图

使用NIO实现非阻塞Socket通信
从图中可以看出，服务器上的所有Channel(包括ServerSocketChannel和SocketChannel)都需要向Selector注册，而该Selector则负责监视这些Socket的IO状态，当其中任意一个或多个Channel具有可用的IO操作时，该Selector的select()方法将会返回大于0的整数，该整数值就表示该Selector上有所烧哥Channel具有可用的IO操作，并提供了selectedKeys()方法来返回这些Channel对应的SelectionKey集合。真是通过Selector,使得服务器端只需要不断地调用Selector实例的select()方法，即可会知道当前的所有Channel是否有需要处理的IO操作。

非阻塞式代码展示及运行结果

Server

package buffer;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.Charset;

public class NServer {
    //用于检测所有Channel状态的Selector
    private Selector selector = null;
    static final int PORT = 30000;
    //定义实现编码，解码的字符集对象
    private Charset charset = Charset.forName("UTF-8");
    public void init () throws IOException{
        selector = Selector.open();
        //通过open方法来打开一个未绑定的ServerSocketChannel实例
        ServerSocketChannel server = ServerSocketChannel.open();
        InetSocketAddress isa = new InetSocketAddress("127.0.0.1",PORT);
        //将该ServerSocketChannel绑定到指定IP地址
        server.bind(isa);
        //设置ServerSocket以非阻塞方式工作
        server.configureBlocking(false);
        //将server注册到指定的Selector对象
        server.register(selector, SelectionKey.OP_ACCEPT);
        while(selector.select()>0){
            //依次处理selector上的每个已选择的SelectionKey
            for(SelectionKey sk : selector.selectedKeys()){
                //从Selector上已选择key集中删除正在处理的SelectionKey
                selector.selectedKeys().remove(sk);
                //如果sk对应的Channel包含客户端的连接请求
                if(sk.isAcceptable()){
                    //调用accpet方法接收连接，产生服务器端的SocketChannel
                    SocketChannel sc = server.accept();
                    //设置采用非阻塞模式
                    sc.configureBlocking(false);
                    //将该SocketChannel也注册到Selector
                    sc.register(selector,SelectionKey.OP_READ);
                    //将sk对应的Channel设置成准备接收其他请求
                    sk.interestOps(SelectionKey.OP_ACCEPT);
                }
               //如果sk对应的Channel有数据需要读取
                if(sk.isReadable()){
                    //获取该SelectionKey对应的Channel,该Channel中有可读的数据
                    SocketChannel sc = (SocketChannel) sk.channel();
                    //定义准备执行读取数据的ByteBuffer



                    ByteBuffer buff = ByteBuffer.allocate(1024);
                    String content = "";
                    //开始读数据
                    try{
                        while(sc.read(buff)>0){
                            buff.flip();
                            content+=charset.decode(buff);
                        }
                        //打印从该sk对应的Channel里读取的数据
                        System.out.println("读取到的数据"+content);
                        //将sk对应的Channel设置成准备下一次读取
                        sk.interestOps(SelectionKey.OP_READ);
                        //如果捕获到该skduiying de Channel出现异常，即表明改改Channel对应的Client出现了问题，所以从Selectir中取消sk的注册

                    }catch(IOException ex){
                        //从Selector中删除指定的SelectionKey
                        sk.cancel();
                        if(sk.channel()!=null){
                            sk.channel().close();
                        }
                    }
                    //如果content的长度大于0，即聊天信息不为空
                    if(content.length()>0){
                        //遍历该selector里注册的所有SelectorKey
                        for(SelectionKey key:selector.keys()){
                            //获取该key对应的Channel
                            Channel targetChannel = key.channel();
                            //如果该channel是注册的所有SelectionKey
                            if(targetChannel instanceof SocketChannel){
                                //将读到的内容写入该Channel中
                                SocketChannel dest = (SocketChannel) targetChannel;
                                dest.write(charset.encode(content));
                            }
                        }
                    }
                }

            }

        }

    }

    public static void main(String[] args) throws IOException {
        new NServer().init();
    }
}

Client

package com.hh.lombok.nio;

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.SocketChannel;
import java.nio.charset.Charset;
import java.util.Scanner;

public class NClient {
    //定义检测SocketChannel的Selector对象
    private Selector selector = null;
    private static int PORT=30000;
    //定义处理编码和解码的字符集
    private Charset charset = Charset.forName("UTF-8");
    //客户端SocketChannel
    private SocketChannel sc = null;
    public void init()throws IOException {
        selector = Selector.open();
        InetSocketAddress isa = new InetSocketAddress("127.0.0.1",PORT);
        //调用open静态方法创建连接到指定主机 的SocketChannel
        sc =SocketChannel.open(isa);
        //设置该sc以非阻塞方式工作
        sc.configureBlocking(false);
        sc.register(selector,SelectionKey.OP_READ);
        //启动读取服务器端数据的线程
        new ClientThread().start();
        //创建键盘输入流
        Scanner scan = new Scanner(System.in);
        while(scan.hasNextLine()){
            //读取键盘输入
            String line = scan.nextLine();
            //将键盘输入的内容输出到SocketChannel中
            sc.write(charset.encode(line));
        }
    }
    //定义读取服务器端数据的线程
    private class ClientThread extends Thread {
        public void run(){
            try {
                //遍历每个有可用IO操作的Channel对应的SelectionKey
                while(selector.select()>0) {
                    for (SelectionKey sk : selector.selectedKeys()) {
                        //删除正在处理的SelectionKey
                        selector.selectedKeys().remove(sk);
                        //如果sk对应的Channel有数据需要读取
                        if (sk.isReadable()) {
                            //获取该SelectionKey对应的Channel,该Channel中有可读的数据
                            SocketChannel sc = (SocketChannel) sk.channel();
                            //定义准备执行读取数据的ByteBuffer
                            ByteBuffer buff = ByteBuffer.allocate(1024);
                            String content = "";
                            //开始读数据

                                while (sc.read(buff) > 0) {
                                    buff.flip();
                                    content += charset.decode(buff);
                                }
                                //打印从该sk对应的Channel里读取的数据
                                System.out.println("读取到的数据" + content);
                                //将sk对应的Channel设置成准备下一次读取
                                sk.interestOps(SelectionKey.OP_READ);
                        }
                    }

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

    public static void main(String[] args) throws IOException {
        new NClient().init();
    }
}