• NIO Selector选择器解析

    选择器以及注册

            选择器的使命是完成IO的多路复用，其主要工作是通道的注册、监听、事件查询。一个通道代表一条连接通路，通过选择器可以同时监控多个通道的IO（输入输出）状况。选择器和通道的关系，是监控和被监控的关系。

            选择器提供了独特的API方法，能够选出（select）所监控的通道已经发生了哪些IO事件，包括读写就绪的IO操作事件。

            在NIO编程中，一般是一个单线程处理一个选择器，一个选择器可以监控很多通道。所以，通过选择器，一个单线程可以处理数百、数千、数万、甚至更多的通道。在极端情况下（数万个连接），只用一个线程就可以处理所有的通道，这样会大量地减少线程之间上下文切换的开销。

            通道和选择器之间的关联，通过register（注册）的方式完成。调用通道的Channel.register（Selector sel，int ops）方法，可以将通道实例注册到一个选择器中。register方法有两个参数：第一个参数，指定通道注册到的选择器实例；第二个参数，指定选择器要监控的IO事件类型。

    可供选择器监控的通道IO事件类型，包括以下四种：

    1. 可读：SelectionKey.OP_READ
    2. 可写：SelectionKey.OP_WRITE
    3. 连接：SelectionKey.OP_CONNECT
    4. 接收：SelectionKey.OP_ACCEPT

            以上的事件类型常量定义在SelectionKey类中。如果选择器要监控通道的多种事件，可以用“按位或”运算符来实现。例如，同时监控可读和可写IO事件：

    1. //监控通道的多种事件，用“按位或”运算符来实现
    2. int key = SelectionKey.OP_READ | SelectionKey.OP_WRITE ;

    注：IO事件不是对通道的IO操作，而是通道处于某个IO操作的就绪状态，表示通道具备执行某个IO操作的条件。比方说：

    1. 某个SocketChannel传输通道，如果完成了和对端的三次握手过程，则会发生“连接就绪”（OP_CONNECT）的事件。
    2. 某个ServerSocketChannel服务器连接监听通道，在监听到一个新连接的到来时，则会发生“接收就绪”（OP_ACCEPT）的事件。
    3. 一个SocketChannel通道有数据可读，则会发生“读就绪”（OP_READ）事件；
    4. 一个等待写入数据的SocketChannel通道，会发生写就绪（OP_WRITE）事件。

    SelectableChannel可选择通道

            并不是所有的通道，都是可以被选择器监控或选择的。比方说，FileChannel文件通道就不能被选择器复用。判断一个通道能否被选择器监控或选择，有一个前提：判断它是否继承了抽象类SelectableChannel（可选择通道），如果是则可以被选择，否则不能。

            简单地说，一条通道若能被选择，必须继承SelectableChannel类。

            SelectableChannel类它提供了实现通道的可选择性所需要的公共方法。Java NIO中所有网络链接Socket套接字通道，都继承了SelectableChannel类，都是可选择的。而FileChannel文件通道，并没有继承SelectableChannel，因此不是可选择通道。

    SelectionKey选择键

            通道和选择器的监控关系，本质是一种多对一的关联关系。这种关联关系，非常类似于数据库两个主表之间的关联关系，通道（Channel）和选择器（Selector）类似于数据库的主表，而选择键（SelectionKey）就类似于关联表，具体如下图所示：

             Selector并不直接去管理Channel，而是直接管理SelectionKey，通过SelectionKey与Channel发生关系。而Java NIO源码中规定了，一个Channel最多能向Selector注册一次，注册之后就形成了唯一的SelectionKey，然后被Selector管理起来。

            Selector有一个核心成员keys，专门用于管理注册上来的SelectionKey，Channel注册到Selector后所创建的那一个唯一的SelectionKey，添加在这个keys成员中，这是一个HashSet类型的集合。除了成员keys之外，Selector还有一个核心成员selectedKeys，用于存放已经发生了IO事件的SelectionKey。

            两核心成员keys、selectedKeys定义在Selector的抽象实现类SelectorImpl中，代码如下：

    1. public abstract class SelectorImpl extends AbstractSelector {
    2.     /**发生了  IO 事件的  Channel 的选择键**/
    3.     protected Set<SelectionKey> selectedKeys = new HashSet();
    4.     /**Channel 注册之后的选择键，一个  channel 在一个  selector 上有一个唯一的 Key**/ 
    5.     protected HashSet<SelectionKey> keys = new HashSet();
    6.     …… 
    7. }

            SelectionKey是IO事件的记录者（或存储者），SelectionKey  有两个核心成员，存储着自己关联的Channel上的感兴趣IO事件和已经发生的IO事件。这两个核心成员定义在实现类SelectionKeyImpl中，代码如下：

    1. public class SelectionKeyImpl extends AbstractSelectionKey {
    2.     final SelChImpl channel; //关联的channel
    3.     public final SelectorImpl selector; //关联的选择键
    4.     private int index;
    5.     private volatile int interestOps;//关联的Channel上的感兴趣IO事件
    6.     private int readyOps;//已经发生的IO事件, 来自关联的Channel
    7.     .....
    8. }

            Channel通道上可以发生多种IO事件，比如说读就绪事件、写就绪事件、新连接就绪事件，但是SelectionKey记录事件的成员却是一个整数类型。这样问题就来了，一个整数如何记录多个事件呢？答案是，通过比特位来完成的。具体的IO事件所占用的哪一个比特位， 通过常量的方式定义在SelectionKey中，如下：

    1.     /**
    2.      * Operation-set bit for read operations.
    3.      *
    4.      * 
       Suppose that a selection key's interest set contains
    5.      * OP_READ at the start of a 
    6.      * href="Selector.html#selop">selection operation.  If the selector
    7.      * detects that the corresponding channel is ready for reading, has reached
    8.      * end-of-stream, has been remotely shut down for further reading, or has
    9.      * an error pending, then it will add OP_READ to the key's
    10.      * ready-operation set and add the key to its selected-key set.  
    11.      */
    12.     public static final int OP_READ = 1 << 0;
    13.  
    14.     /**
    15.      * Operation-set bit for write operations.
    16.      *
    17.      * 
       Suppose that a selection key's interest set contains
    18.      * OP_WRITE at the start of a 
    19.      * href="Selector.html#selop">selection operation.  If the selector
    20.      * detects that the corresponding channel is ready for writing, has been
    21.      * remotely shut down for further writing, or has an error pending, then it
    22.      * will add OP_WRITE to the key's ready set and add the key to its
    23.      * selected-key set.  
    24.      */
    25.     public static final int OP_WRITE = 1 << 2;
    26.  
    27.     /**
    28.      * Operation-set bit for socket-connect operations.
    29.      *
    30.      * 
       Suppose that a selection key's interest set contains
    31.      * OP_CONNECT at the start of a 
    32.      * href="Selector.html#selop">selection operation.  If the selector
    33.      * detects that the corresponding socket channel is ready to complete its
    34.      * connection sequence, or has an error pending, then it will add
    35.      * OP_CONNECT to the key's ready set and add the key to its
    36.      * selected-key set.  
    37.      */
    38.     public static final int OP_CONNECT = 1 << 3;
    39.  
    40.     /**
    41.      * Operation-set bit for socket-accept operations.
    42.      *
    43.      * 
       Suppose that a selection key's interest set contains
    44.      * OP_ACCEPT at the start of a 
    45.      * href="Selector.html#selop">selection operation.  If the selector
    46.      * detects that the corresponding server-socket channel is ready to accept
    47.      * another connection, or has an error pending, then it will add
    48.      * OP_ACCEPT to the key's ready set and add the key to its
    49.      * selected-key set.  
    50.      */
    51.     public static final int OP_ACCEPT = 1 << 4;

            通过SelectionKey的interestOps成员上相应的比特位，可以设置、查询关联的Channel所感兴趣的IO事件；通过SelectionKey的readyOps上相应的比特位，可以查询关联Channel所已经发生的IO事件。对于interestOps成员上的比特位，应用程序是可以设置的；但是对于readyOps上的比特位，应用程序只能查询，不能设置。为啥呢？readyOps上的比特位代表了已经发生的IO事件，是由选择器Selector去设置的，应用程序只能获取。

            通道和选择器的监控关系注册成功后，Selector就可以查询就绪事件。具体的查询操作，是通过调用选择器Selector的select( )系列方法来完成。通过select系列方法，选择器会通过JNI，去进行底层操作系统的系统调用（比如select/epoll），可以不断地查询通道中所发生操作的就绪状态（或者IO事件），并且把这些发生了底层IO事件，转换成Java NIO中的IO事件，记录在的通道关联的SelectionKey的readyOps上。除此之外，发生了IO事件的选择键，还会记录在Selector内部selectedKeys集合中。

            简单来说，一旦在通道中发生了某些IO事件（就绪状态达成），这个事件就被记录在SelectionKey的readyOps上，并且这个SelectionKey被记录在Selector内部的selectedKeys集合中。当然，这里有两个前提：

    1. 通道必须在Selector注册过；
    2. 所发生的事件必须是SelectionKey上interestOps成员记录的事件。

            在实际编程时，选择键的功能是很强大的。通过SelectionKey选择键，不仅仅可以获得通道的IO事件类型，比方说SelectionKey.OP_READ；还可以获得发生IO事件所在的通道；另外，也可以获得Selector选择器实例。所以，这个一个非常重要的中间类或者胶水类。

    选择器使用流程

    使用选择器，主要有以下三步：

    1. 获取选择器实例；
    2. 将通道注册到选择器中；
    3. 轮询感兴趣的IO就绪事件（选择键集合）。

    第一步：获取选择器实例。选择器实例是通过调用静态工厂方法open()来获取的，具 
    体如下：

    1. //调用静态工厂方法  open()来获取  Selector 实例 
    2. Selector selector = Selector.open();

            Selector选择器的类方法open( )的内部，是向选择器SPI（SelectorProvider）发出请求，通过默认的SelectorProvider（选择器提供者）对象，获取一个新的选择器实例。Java中SPI全称为（Service Provider Interface，服务提供者接口），是JDK的一种可以扩展的服务提供和发现机制。Java通过SPI的方式，提供选择器的默认实现版本。也就是说，其他的服务提供商可以通过SPI的方式，提供定制化版本的选择器的动态替换或者扩展。 

            第二步：将通道注册到选择器实例。要实现选择器管理通道，需要将通道注册到相应 
    的选择器上，简单的示例代码如下：

    1. // 2.获取通道
    2. ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); 
    3. // 3.设置为非阻塞
    4. serverSocketChannel.configureBlocking(false); 
    5. // 4.绑定连接
    6. serverSocketChannel.bind(new InetSocketAddress(18899));
    7. // 5.将通道注册到选择器上,并制定监听事件为：“接收连接”事件
    8. serverSocketChannel.register(selector，SelectionKey.OP_ACCEPT);

         上面通过调用通道的register(…)方法，将ServerSocketChannel通道注册到了一个选择器 
    上。当然，在注册之前，首先需要准备好通道。

    注：

    1. 注册到选择器的通道，必须处于非阻塞模式下，否则将抛出IllegalBlockingModeException异常。这意味着，FileChannel文件通道不能与选择器一起使用，因为FileChannel文件通道只有阻塞模式，不能切换到非阻塞模式；而Socket套接字相 关的所有通道都可以。
    2. 一个通道，并不一定要支持所有的四种IO事件。例如服务器监听通ServerSocketChannel，仅仅支持Accept（接收到新连接）IO事件；而传输通道SocketChannel则不同，该类型通道不支持Accept类型的IO事件。
    3. 可以在注册之前，可以通过通道的validOps()方法，来获取该通道所有支持的IO事件集合。

            第三步：选出感兴趣的IO就绪事件（选择键集合）。通过Selector选择器的select()方 
    法，选出已经注册的、已经就绪的IO事件，并且保存到SelectionKey选择键集合中。 
    SelectionKey集合保存在选择器实例内部，其元素为SelectionKey类型实例。调用选择器的 
    selectedKeys()方法，可以取得选择键集合。

            接下来，需要迭代集合的每一个选择键，根据具体IO事件类型，执行对应的业务操 
    作。大致的处理流程如下：

    1. //轮询，选择感兴趣的  IO 就绪事件（选择键集合） 
    2. while (selector.select() > 0) {
    3.     Set selectedKeys = selector.selectedKeys(); 
    4.     Iterator keyIterator = selectedKeys.iterator(); 
    5.     while(keyIterator.hasNext()) {
    6.         SelectionKey key = keyIterator.next(); 
    7.         //根据具体的  IO 事件类型，执行对应的业务操作
    8.         if(key.isAcceptable()) {
    9.         // IO 事件：ServerSocketChannel 服务器监听通道有新连接 
    10.         } else if (key.isConnectable()) {
    11.         // IO 事件：传输通道连接成功
    12.         } else if (key.isReadable()) { 
    13.         // IO 事件：传输通道可读
    14.         } else if (key.isWritable()) { 
    15.         // IO 事件：传输通道可写
    16.         }
    17.         //处理完成后，移除选择键 
    18.         keyIterator.remove();
    19.     } 
    20. }

            处理完成后，需要将选择键从这个SelectionKey集合中移除，防止下一次循环的时候，被重复的处理。SelectionKey集合不能添加元素，如果试图向SelectionKey选择键集合中添加元素，则将抛出java.lang.UnsupportedOperationException异常。

    用于选择就绪的IO事件的select()方法，有多个重载的实现版本，具体如下：

    1. select()：阻塞调用，一直到至少有一个通道发生了注册的IO事件。
    2. select(long timeout)：和select()一样，但最长阻塞时间为timeout指定的毫秒数。
    3. selectNow()：非阻塞，不管有没有IO事件，都会立刻返回。

            select()方法的返回值的是整数类型（int），表示发生了IO事件的数量。更准确地说， 
    是从上一次select到这一次select之间，有多少通道发生了IO事件，更加准确地说，是指发 
    生了选择器感兴趣（注册过）的IO事件数。

    使用NIO实现Discard服务器的实践案例

            Discard服务器的功能很简单：仅仅读取客户端通道的输入数据，读取完成后直接关闭 
    客户端通道；并且读取到的数据直接抛弃掉（Discard）。Discard服务器足够简单明了，作 
    为第一个学习NIO的通信实例，较有参考价值。

    下面的Discard服务器代码，其中将选择器使用流程中的步骤进行了进一步细化：

    1. public class NioDiscardServer {
    2.     public static void startServer() throws IOException { 
    3.         // 1.获取选择器
    4.         Selector selector = Selector.open(); 
    5.         // 2.获取通道
    6.         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    7.         // 3.设置为非阻塞
    8.         serverSocketChannel.configureBlocking(false); 
    9.         // 4.绑定连接
    10.         serverSocketChannel.bind(newInetSocketAddress(18899)); 
    11.         Logger.info("服务器启动成功");
    12.         // 5.将通道注册的“接收新连接”IO 事件，注册到选择器上 
    13.         serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
    14.         // 6.轮询感兴趣的  IO 就绪事件（选择键集合） 
    15.         while (selector.select() > 0) {
    16.             // 7.获取选择键集合
    17.             Iterator selectedKeys =selector.selectedKeys().iterator();
    18.             while (selectedKeys.hasNext()) { 
    19.             // 8.获取单个的选择键，并处理
    20.             SelectionKey selectedKey = selectedKeys.next(); 
    21.             // 9.判断  key 是具体的什么事件
    22.             if (selectedKey.isAcceptable()) {
    23.                 // 10.若选择键的  IO 事件是“连接就绪”事件,就获取客户端连接 
    24.                 SocketChannel socketChannel =serverSocketChannel.accept();
    25.                 // 11.将新连接切换为非阻塞模式
    26.                 socketChannel.configureBlocking(false);
    27.                 // 12.将该新连接的通道的可读事件，注册到选择器上 
    28.                 socketChannel.register(selector, SelectionKey.OP_READ);
    29.             } else if (selectedKey.isReadable()) {
    30.                 // 13.若选择键的  IO 事件是“可读”事件, 读取数据 
    31.                 SocketChannelsocketChannel =(SocketChannel) selectedKey.channel(); 
    32.                 // 14.读取数据，然后丢弃
    33.                 ByteBufferbyteBuffer = ByteBuffer.allocate(1024); 
    34.                 int length = 0;
    35.                 while ((length =socketChannel.read(byteBuffer)) >0) 
    36.                 {
    37.                     byteBuffer.flip();
    38.                     Logger.info(new String(byteBuffer.array(), 0, length));
    39.                     byteBuffer.clear(); 
    40.                 }
    41.                 socketChannel.close(); 
    42.             }
    43.             // 15.移除选择键 
    44.             selectedKeys.remove();
    45.         } 
    46.     }
    47.     // 16.关闭连接
    48.     serverSocketChannel.close(); 
    49.     }
    50.     public static void main(String[] args) throws IOException {
    51.         startServer(); 
    52.     }
    53. }

            实现DiscardServer丢弃服务一共分为16步，其中第7到第15步是循环执行的，不断查询选择感兴趣的IO事件到选择键集合中，然后通过selector.selectedKeys()获取该选择键集合，并且进行迭代处理。在事件处理过程中，对于新建立的socketChannel客户端传输通道，也要注册到同一个选择器上，这样就能使用同一个选择线程，不断地对所有的注册通道进行选择键的查询。

            在DiscardServer程序中，涉及到两次选择器注册：一次是注册serverChannel服务器通道；另一次，注册接收到的socketChannel客户端传输通道。前者serverChannel服务器通道所注册的，是新连接的IO事件SelectionKey.OP_ACCEPT；后者客户端传输通道socketChannel所注册的，是可读IO事件SelectionKey.OP_READ。

            注册完成后如果有事件发生，也就是DiscardServer在对选择键进行处理时，通过对类型进行判断，然后进行相应的处理：

    1. 如果是SelectionKey.OP_ACCEPT新连接事件类型，代表serverChannel服务器通道接收到新的客户端连接，发生了新连接事件，则通过服务器通道的accept方法，获取新的socketChannel传输通道，并且将新通道注册到选择器；
    2. 如果是SelectionKey.OP_READ可读事件类型，代表某个客户端通道有数据可读，则读取选择键中socketChannel传输通道的数据，进行业务处理，这里是直接丢弃数据。

    客户端的DiscardClient代码，则更为简单。客户端首先建立到服务器的连接，发送一些简单的数据，然后直接关闭连接。代码如下：

    1. public class NioDiscardClient {
    2.     public static void startClient() throws IOException {
    3.         InetSocketAddress address =new InetSocketAddress("127.0.0.1",18899);
    4.         // 1.获取通道
    5.         SocketChannel socketChannel = SocketChannel.open(address); 
    6.         // 2.切换成非阻塞模式
    7.         socketChannel.configureBlocking(false); 
    8.         //不断地自旋、等待连接完成，或者做一些其他的事情
    9.         while (!socketChannel.finishConnect()) { 
    10.         }
    11.         Logger.info("客户端连接成功"); 
    12.         // 3.分配指定大小的缓冲区
    13.         ByteBuffer byteBuffer = ByteBuffer.allocate(1024); 
    14.         byteBuffer.put("hello world".getBytes()); 
    15.         byteBuffer.flip();
    16.         //发送到服务器
    17.         socketChannel.write(byteBuffer);
    18.         socketChannel.shutdownOutput();
    19.         socketChannel.close();
    20.     }
    21.     public static void main(String[] args) throws IOException {
    22.         startClient(); 
    23.     }
    24. }

    使用SocketChannel在服务器端接收文件的实践案例

    服务器端接收文件的示例代码如下所示：

    1. public class NioReceiveServer
    2. {
    3.     //接受文件路径
    4.     private static final String RECEIVE_PATH = NioDemoConfig.SOCKET_RECEIVE_PATH;
    5.     private Charset charset = Charset.forName("UTF-8");
    6.     /**
    7.     * 服务器端保存的客户端对象，对应一个客户端文件 
    8.     */
    9.     static class Client 
    10.     {
    11.     //文件名称 
    12.     String fileName; 
    13.     //长度
    14.     long fileLength; 
    15.     //开始传输的时间
    16.     long startTime; 
    17.     //客户端的地址
    18.     InetSocketAddress remoteAddress; 
    19.     //输出的文件通道
    20.     FileChannel outChannel; 
    21.     //接收长度
    22.     long receiveLength; 
    23.     public boolean isFinished()
    24.     {
    25.         return receiveLength >= fileLength; 
    26.     }
    27.     private ByteBuffer buffer= ByteBuffer.allocate(NioDemoConfig.SERVER_BUFFER_SIZE);
    28.     //使用  Map 保存每个客户端传输
    29.     //当  OP_READ 通道可读时，根据  channel 找到对应的对象
    30.     Map clientMap = new HashMap();
    31.     public void startServer() throws IOException 
    32.     {
    33.         // 1、获取  Selector 选择器
    34.         Selector selector = Selector.open();
    35.         // 2、获取通道
    36.         ServerSocketChannel serverChannel = ServerSocketChannel.open();
    37.         ServerSocket serverSocket = serverChannel.socket();
    38.         // 3.设置为非阻塞
    39.         serverChannel.configureBlocking(false); 
    40.         // 4、绑定连接
    41.         InetSocketAddress address= new InetSocketAddress(18899); 
    42.         serverSocket.bind(address);
    43.         // 5、将通道注册到选择器上,并注册的  IO 事件为：“接收新连接” 
    44.         serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    45.         // 6、轮询感兴趣的  I/O 就绪事件（选择键集合） 
    46.         while (selector.select() > 0)
    47.         {
    48.             // 7、获取选择键集合
    49.             Iterator it =selector.selectedKeys().iterator();
    50.             while (it.hasNext()) 
    51.             {
    52.                 // 8、获取单个的选择键，并处理 
    53.                 SelectionKey key = it.next();
    54.                 // 9、判断  key 是具体的什么事件，是否为新连接事件 
    55.                 if (key.isAcceptable())
    56.                 {
    57.                     // 10、若接受的事件是“新连接”事件,就获取客户端新连接 
    58.                     ServerSocketChannel server =(ServerSocketChannel) key.channel();
    59.                     SocketChannel socketChannel = server.accept(); 
    60.                     if (socketChannel == null) continue;
    61.                         // 11、客户端新连接，切换为非阻塞模式 
    62.                         socketChannel.configureBlocking(false); 
    63.                         // 12、将客户端新连接通道注册到  selector 选择器上 
    64.                         SelectionKey selectionKey =socketChannel.register(selector, SelectionKey.OP_READ);
    65.                         // 余下为业务处理
    66.                         Client client = new Client(); 
    67.                         client.remoteAddress  =(InetSocketAddress) socketChannel.getRemoteAddress(); 
    68.                         clientMap.put(socketChannel, client);
    69.                         Logger.debug(socketChannel.getRemoteAddress() + "连接成功...");
    70.                     } else if (key.isReadable()) 
    71.                     {
    72.                         processData(key);
    73.                     }
    74.                     // NIO 的特点只会累加，已选择的键的集合不会删除 
    75.                     // 如果不删除，下一次又会被  select 函数选中 
    76.                     it.remove();
    77.                 } 
    78.         }
    79.     
    80.     /**
    81.     * 处理客户端传输过来的数据 
    82.     */
    83.     private void processData(SelectionKey key) throws IOException 
    84.     {
    85.         Client client = clientMap.get(key.channel());
    86.         SocketChannel socketChannel = (SocketChannel) key.channel(); 
    87.         int num = 0;
    88.         try 
    89.         {
    90.             buffer.clear();
    91.             while ((num = socketChannel.read(buffer)) > 0) 
    92.             {
    93.                 buffer.flip();
    94.                 //客户端发送过来的，首先处理文件名 
    95.                 if (null == client.fileName) 
    96.                 {
    97.                     if (buffer.capacity() < 4) 
    98.                     {
    99.                         continue; 
    100.                     }
    101.                     int fileNameLen = buffer.getInt();
    102.                     byte[] fileNameBytes = new byte[fileNameLen]; 
    103.                     buffer.get(fileNameBytes);
    104.                     // 文件名
    105.                     String fileName = new String(fileNameBytes, charset);
    106.                     File directory = new File(RECEIVE_PATH); 
    107.                     if (!directory.exists())
    108.                     {
    109.                         directory.mkdir(); 
    110.                     }
    111.                     Logger.info("NIO  传输目标  dir：", directory);
    112.                     client.fileName = fileName; 
    113.                     String fullName = directory.getAbsolutePath() + File.separatorChar + fileName;
    114.                     Logger.info("NIO  传输目标文件：", fullName);
    115.                     File file = new File(fullName.trim()); 
    116.                     if (!file.exists())
    117.                     {
    118.                         file.createNewFile(); 
    119.                     }
    120.                     FileChannel fileChannel =new FileOutputStream(file).getChannel(); 
    121.                     client.outChannel = fileChannel;
    122.                     if (buffer.capacity() < 8) 
    123.                     {
    124.                         continue; 
    125.                     }
    126.                     // 文件长度
    127.                     long fileLength = buffer.getLong(); 
    128.                     client.fileLength = fileLength;
    129.                     client.startTime = System.currentTimeMillis(); 
    130.                     Logger.debug("NIO  传输开始：");
    131.                     client.receiveLength += buffer.capacity(); 
    132.                     if (buffer.capacity() > 0)
    133.                     {
    134.                         // 写入文件
    135.                         client.outChannel.write(buffer); 
    136.                     }
    137.                     if (client.isFinished()) 
    138.                     {
    139.                         finished(key, client); 
    140.                     }
    141.                     buffer.clear();
    142.                 }
    143.                 //客户端发送过来的，最后是文件内容 
    144.                 else
    145.                 {
    146.                     client.receiveLength += buffer.capacity(); 
    147.                     // 写入文件
    148.                     client.outChannel.write(buffer); 
    149.                     if (client.isFinished())
    150.                     {
    151.                         finished(key, client); 
    152.                     }
    153.                     buffer.clear(); 
    154.                 }
    155.              }
    156.                 key.cancel();
    157.             } catch (IOException e)
    158.             {
    159.                 key.cancel();
    160.                 e.printStackTrace(); 
    161.                 return;
    162.             }
    163.             // 调用  close 为-1 到达末尾 
    164.             if (num == -1)
    165.             {
    166.                 finished(key, client); 
    167.                 buffer.clear();
    168.             } 
    169.         }
    170.     private void finished(SelectionKey key, Client client) 
    171.     {
    172.         IOUtil.closeQuietly(client.outChannel); 
    173.         Logger.info("上传完毕");
    174.         key.cancel();
    175.         Logger.debug("文件接收成功,File Name：" + client.fileName); 
    176.         Logger.debug(" Size：" +
    177.         IOUtil.getFormatFileSize(client.fileLength));
    178.         long endTime = System.currentTimeMillis();
    179.         Logger.debug("NIO IO 传输毫秒数：" +
    180.         (endTime - client.startTime));
    181.     }
    182.     /** 
    183.     * 入口 
    184.     */
    185.     public static void main(String[] args) throws Exception 
    186.     {
    187.         NioReceiveServer server = new NioReceiveServer(); 
    188.         server.startServer();
    189.     } 
    190.     }
    191. }

    由于客户端每次传输文件，都会分为多次传输：

    1. 首先传入文件名称；
    2. 其次是文件大小；
    3. 然后是文件内容。

            对应于每一个客户端socketChannel，创建一个Client客户端对象，用于保存客户端状态，分别保存文件名、文件大小和写入的目标文件通道outChannel。

            socketChannel和Client对象之间是一对一的对应关系：建立连接的时候，以键值对的形式保存Client实例在map中，其中socketChannel作为键（Key），Client对象作为值（Value）。当socketChannel传输通道有数据可读时，通过选择键key.channel()方法，取出IO事件所在socketChannel通道。然后通过socketChannel通道，从map中取到对应的Client对象。

            接收到数据时，如果文件名为空，先处理文件名称，并把文件名保存到Client对象，同时创建服务器上的目标文件；接下来再读到数据，说明接收到了文件大小，把文件大小保存到Client对象；接下来再接到数据，说明是文件内容了，则写入Client对象的outChannel文件通道中，直到数据读取完毕。

            运行方式：启动这个NioReceiveServer服务器程序后，再启动前面介绍的客户端程序NioSendClient，即可以完成文件的传输。

            由于NIO传输是非阻塞的、异步的，所以，在传输过程中会出现“粘包”和“半包”问题。正因为这个原因，无论是前面NIO文件传输实例、还是Discard服务器程序，都会在传输过程中的出现异常现象（偶现）。

    小结

            在编程难度上，Java NIO编程的难度比同步阻塞Java OIO编程大很多。与Java OIO相比，Java NIO编程大致的特点如下：

    1. 在NIO中，服务器接收新连接的工作，是异步进行的。不像Java的OIO那样，服务器监听连接，是同步的、阻塞的。NIO可以通过选择器（也可以说成：多路复用器），后续不断地轮询选择器的选择键集合，选择新到来的连接。
    2. 在NIO中，SocketChannel传输通道的读写操作都是异步的。如果没有可读写的数据，负责IO通信的线程不会同步等待。这样，线程就可以处理其他连接的通道；不需要像OIO那样，线程一直阻塞，等待所负责的连接可用为止。
    3. 在NIO中，一个选择器线程可以同时处理成千上万的客户端连接，性能不会随着客户端的增加而线性下降。

            总之，有了Linux底层的epoll支持，以及Java NIO Selector选择器等等应用层IO复用技术，Java程序从而可以实现IO通信的高TPS、高并发，使服务器具备并发数十万、数百万的连接能力。Java的NIO技术非常适合用于高性能、高负载的网络服务器。鼎鼎大名的通信服务器中间件Netty，就是基于Java的NIO技术实现的。

  • 相关阅读:
    合取范式可满足性问题：CDCL（Conflict-Driven Clause Learning）算法详解
    出差学小白知识No6：LD_PRELOAD变量路径不对找不到库文件
    SpringMVC之JSON数据返回与异常处理机制
    Kafka中Producer源码解读
    styleSwin的各种bug
    【双指针+简化去重操作】Leetcode 15 三数之和
    SpringBoot使用配置文件若干方式
    python网络爬虫笔记15：使用js验证获取网页的请求头信息和请求参数
    ThinkPHP 接口开发过程
    好用的5款火狐浏览器必备插件，每一款都很实用
  • 原文地址：https://blog.csdn.net/ntzzzsj/article/details/126146980