NIO 的非阻塞式网络通信

1.阻塞与非阻塞
   ①  传统的 IO 流都是阻塞式的。也就是说，当一个线程调用 read() 或 write()时，

该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。

因此，在完成网络通信进行 IO 操作时，由于线程会阻塞，

所以服务器端必须为每个客户端都提供一个独立的线程进行处理，

当服务器端需要处理大量客户端时，性能急剧下降。

② Java NIO 是非阻塞模式的。当线程从某通道进行读写数据时，若没有数据可用时，

该线程可以进行其他任务。线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作，

所以单独的线程可以管理多个输入和输出通道。、

因此，NIO 可以让服务器端使用一个或有限几个线程来同

时处理连接到服务器端的所有客户端。

阻塞式：TestBlockingNIO

package com.aff.nio2;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

import org.junit.Test;

/*使用NIO完成网络通信的三个核心技术
    1.通道(Channel):负责连接
        java.nio.channels.Channel  接口:
             |----SockableChannel
                       |----SocketChannel
                       |----ServerSocketChannel
                       |----DatagramChannel
                       |
                       |----Pipe.SinkChannel
                       |----Pipe.SourceChannel

      2.缓冲区(Buffer):负责数据的存储
      3.选择器(Selector):是SelectorableChannel的多路复用器。
         用于监控SelectableChannel的IO状况 

*/
//阻塞式IO
public class TestBlockingNIO {
    // 客户端
    @Test
    public void client() throws IOException {
        // 1.获取通道
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("192.168.3.10", 8989));
        FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
        // 2.分配指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        // 3.读取本地文件
        while ((inChannel.read(buf)) != -1) {
            buf.flip();
            sChannel.write(buf);
            buf.clear();
        }
        // 关闭通道
        inChannel.close();
        sChannel.close();
    }

    // 服务端
    @Test
    public void server() throws IOException {
        // 1.获取通道
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        FileChannel outChannel = FileChannel.open(Paths.get("8.jpg"), StandardOpenOption.WRITE,
                StandardOpenOption.CREATE);

        // 2.绑定端口号
        ssChannel.bind(new InetSocketAddress(8989));

        // 3.获取客户端连接的通道
        SocketChannel sChannel = ssChannel.accept();

        // 4.分配指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);

        // 5.接受客户端的数据，并保存到本地
        while ((sChannel.read(buf)) != -1) {
            buf.flip();
            outChannel.write(buf);
            buf.clear();
        }
        // 6.关闭通道
        ssChannel.close();
        outChannel.close();
        ssChannel.close();
    }
}

2.选择器（Selector） ）
   ① 选择器（Selector）是 SelectableChannle 对象的多路复用器，

Selector 可以同时监控多个 SelectableChannel 的 IO 状况，

也就是说，利用 Selector可使一个单独的线程管理多个 Channel。

Selector 是非阻塞 IO 的核心。

   ② SelectableChannle 的结构如下图：

3.选择 器（Selector ）的应用
    ①当调用 register(Selector sel, int ops) 将通道注册选择器时，选择器
        对通道的监听事件，需要通过第二个参数 ops 指定。
    ②可以监听的事件类型（用 可使用 SelectionKey 的四个常量 表示）：
                  读 : SelectionKey.OP_READ （1）
                  写 : SelectionKey.OP_WRITE （4）
              连接 : SelectionKey.OP_CONNECT （8）
              接收 : SelectionKey.OP_ACCEPT （16）
    ③若注册时不止监听一个事件，则可以使用“位或”操作符连接

非阻塞式IO：TestBlockingNIO2

package com.aff.nio2;

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.Date;
import java.util.Iterator;
import java.util.Scanner;

import org.junit.Test;

//非阻塞式IO
public class TestBlockingNIO2 {
    // 客户端
    @Test
    public void client() throws IOException {
        // 1.获取通道
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("192.168.3.10", 8989));

        // 2.切换非阻塞式模式
        sChannel.configureBlocking(false);

        // 3.分配指定大小的缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);

        // 4.发送数据给服务端
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) { // 相当于聊天室功能了
            String str = scan.next();
            buf.put((new Date().toString() + "\n" + str).getBytes());
            buf.flip();
            sChannel.write(buf);
            buf.clear();
        }

        // 关闭通道
        sChannel.close();
    }

    // 服务端
    @Test
    public void server() throws IOException {
        // 1.获取通道
        ServerSocketChannel ssChannel = ServerSocketChannel.open();

        // 2.切换非阻塞模式
        ssChannel.configureBlocking(false);

        // 3..绑定端口号
        ssChannel.bind(new InetSocketAddress(8989));

        // 4..获取选择器
        Selector selector = Selector.open();

        // 5.将通道注册到选择器上,并且指定监听接受事件
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 6.轮巡式的获取选择器上已经 准备就绪 的事件
        while (selector.select() > 0) {
            // 7.获取当前选择器中所有注册的"选择键(已就绪的监听事件)"
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();

            // 8.迭代获取
            while (it.hasNext()) {
                SelectionKey sk = it.next();
                // 9.判断是什么事件准备就绪
                if (sk.isAcceptable()) {
                    // 10.若"接收就绪"，获取客户端连接
                    SocketChannel sChannel = ssChannel.accept();

                    // 11.切换非阻塞
                    sChannel.configureBlocking(false);

                    // 将该通道注册到选择器上
                    sChannel.register(selector, SelectionKey.OP_READ);
                } else if (sk.isReadable()) {
                    // 获取当前选择器上"读就绪"的通道
                    SocketChannel Schannel = (SocketChannel) sk.channel();

                    // 读取数据
                    int len = 0;
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    while ((len = Schannel.read(buf)) > 0) {
                        buf.flip();
                        System.out.println(new String(buf.array(), 0, len));
                        buf.clear();
                    }
                }
                // 取消选择键
                it.remove();
            }
        }
    }
}
执行效果

Sun Apr 05 17:34:26 CST 2020
nihaoa
nisha
Sun Apr 05 17:34:44 CST 2020
nihenhao

DatagramChannel：Java NIO中的DatagramChannel是一个能收发UDP包的通道

DatagramChannel： TestBlockingUDP 

package com.aff.nio2;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.util.Date;
import java.util.Iterator;
import java.util.Scanner;

import org.junit.Test;

public class TestBlockingUDP {
    @Test
    public void send() throws IOException {
        DatagramChannel dc = DatagramChannel.open();

        dc.configureBlocking(false);

        ByteBuffer buf = ByteBuffer.allocate(1024);

        Scanner scan = new Scanner(System.in);

        while (scan.hasNext()) {
            String str = scan.next();
            buf.put((new Date().toString() + ":\n" + str).getBytes());
            buf.flip();
            dc.send(buf, new InetSocketAddress("192.168.3.10", 9898));
            buf.clear();
        }

        dc.close();
    }

    @Test
    public void receive() throws IOException {
        DatagramChannel dc = DatagramChannel.open();

        dc.configureBlocking(false);

        dc.bind(new InetSocketAddress(9898));

        Selector selector = Selector.open();

        dc.register(selector, SelectionKey.OP_READ);

        while (selector.select() > 0) {
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();

            while (it.hasNext()) {
                SelectionKey sk = it.next();

                if (sk.isReadable()) {
                    ByteBuffer buf = ByteBuffer.allocate(1024);

                    dc.receive(buf);
                    buf.flip();
                    System.out.println(new String(buf.array(), 0, buf.limit()));
                    buf.clear();
                }
            }
            it.remove();
        }
    }
}

管道 (Pipe)：
  Java NIO 管道是2个线程之间的单向数据连接。
   Pipe有一个source通道和一个sink通道。数据会
   被写到sink通道，从source通道读取。

TestPipe

package com.aff.nio2;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;

import org.junit.Test;

public class TestPipe {

    @Test
    public void test1() throws IOException {
        // 1. 获取管道
        Pipe pipe = Pipe.open();

        // 2. 将缓冲区中的数据写入管道
        ByteBuffer buf = ByteBuffer.allocate(1024);

        Pipe.SinkChannel sinkChannel = pipe.sink();
        buf.put("通过单向管道发送数据".getBytes());
        buf.flip();
        sinkChannel.write(buf);

        // 3. 读取缓冲区中的数据
        Pipe.SourceChannel sourceChannel = pipe.source();
        buf.flip();
        int len = sourceChannel.read(buf);
        System.out.println(new String(buf.array(), 0, len));

        sourceChannel.close();
        sinkChannel.close();
    }
}