Java NIO的理解和应用

Java NIO是一种基于通道和缓冲区的I/O方式，已经被广泛的应用，成为解决高并发与大量连接和I/O处理问题的有效方式。

Java NIO相关组件

Java NIO主要有三个核心部分组成，分别是：Channel(通道)，Buffer(缓冲区), Selector（选择器）

• Channel

Channel是所有访问IO设备的统称。类型与IO中的Stream，而通道是双向的，既可以读又可以写，但是Stream是单项的。常用的通道有：SocketChannel和ServerSocketChannel（对应TCP的客户端和服务器端）、FileChannel（对应文件IO）、DatagramChannel（对应UDP）等

• Buffer

所有数据的读写都要经过Buffer，Buffer直接和Channel打交道，是一个存储数据的容器。通过调用Channel.write方法将数据写入Buffer，Channel.read方法将数据从Buffer中读取出来。常用的Buffer有：ByteBuffer、LongBuffer、IntBuffer、StringCharBuffer等

• Selector

Selector用来监听多个Channel的事件（比如：Read、Write、Connect和Accept等），通过单个线程轮询的方式实现了对多个Channel的监听。

Java IO与NIO的区别

NIO是一种叫非阻塞IO（Non-blocking I/O），基于I/O多路复用来实现的（可参考：I/O模型、select、poll和epoll之间的区别）。NIO与之前传统的I/O模型有很大的不同，具体表现在以下几个方面：

• 面向流与面向缓冲

Java IO和NIO之间一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。Java IO每次从数据流中读一个或多个字节，直至读取所有字节，数据流是一次性的，读取完以后，不能前后移动流中的数据。Java NIO是将数据读取到缓冲区，可以通过position来回移动访问缓冲区中的数据。

• 阻塞与非阻塞IO

Java IO中调用read和write方法的线程会被阻塞的，直到数据全部读入或者全部写入完为止。而在Java NIO中，如果需要读写数据只用和缓冲区打交道，将数据从缓冲区读取或者写入缓冲区以后，线程可以继续做其他事情，不会被block住。

• 选择器（Selector）

Selector是基于I/O多路复用的机制实现的，将多个Channel注册到一个Selector上，Selector通过轮询监听所有注册的通道上是否有SelectionKey发生，如果发生了，然后将SelectionKey分派给其他线程处理。

Java NIO的应用

通过Java NIO技术简单实现了一个服务端与客户端通信的case，具体功能如下：

• 服务端可以向客户端广播消息
• 服务端将一个客户端的消息转发给其他客户端
• 客户端向服务端发送消息
• 客户端接收服务端的消息

服务端代码如下：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Server {

    public static void main(String[] args) throws IOException {
        new Server().start(); // 启动服务端程序
    }

    public Server() throws IOException {
        this.init(); // 初始化服务端数据
    }

    /**
     * 服务端端口
     */
    private int port = 9999;

    /**
     * 服务端的Selector用来监听Channel的事件.
     */
    private Selector selector;

    /**
     * 字符数据编码
     */
    private Charset charset = Charset.forName("UTF-8");

    /**
     * 读缓存，分配1024Byte的空间
     */
    private ByteBuffer readBuffer = ByteBuffer.allocate(1024);

    /**
     * 写缓存，分配1024Byte的空间
     */
    private ByteBuffer writeBuffer = ByteBuffer.allocate(1024);

    /**
     * 存储所有客户端的Channel，转发的时候使用
     */
    private Map<String, Channel> clientSocketChannels = new HashMap<>();

    /**
     * 定义了一个线程池，服务端用来发送数据给客户端
     */
    private static ExecutorService executorService = Executors.newFixedThreadPool(1, runnable -> {
        Thread thread = new Thread(runnable);
        thread.setDaemon(true);
        thread.setName("server-sender");
        return thread;
    });

    /**
     * 初始化Channel.
     */
    private void init() throws IOException {
        // 声明一个服务端的ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 将服务端的ServerSocketChannel设置成非阻塞模式
        serverSocketChannel.configureBlocking(false);
        // 设置服务端的socket
        ServerSocket serverSocket = serverSocketChannel.socket();
        serverSocket.bind(new InetSocketAddress(this.port));
        // 声明一个Selector，用来监听服务端的所有Channel
        this.selector = Selector.open();
        // 在ServerSocketChannel上注册Accept事件，用来接收客户端的连接
        serverSocketChannel.register(this.selector, SelectionKey.OP_ACCEPT);
        System.out.println("Server is started, the port is " + this.port);
    }

    /**
     * 处理服务端监听到的事件
     */
    private void work(SelectionKey selectionKey) throws IOException {
        // 客户端有Socket连接请求
        if (selectionKey.isAcceptable()) {
            // 从SelectionKey中获取服务端的ServerSocketChannel，SelectionKey中包含了服务端与客户端的所有信息
            ServerSocketChannel serverSocketChannel = (ServerSocketChannel) selectionKey.channel();
            // 服务端打开一个新的SocketChannel用来与客户端的SocketChannel进行通信，服务端同时会随机分配一个端口
            SocketChannel socketChannel = serverSocketChannel.accept();
            // 将SocketChannel设置成非阻塞模式
            socketChannel.configureBlocking(false);
            // 将SocketChannel中的Read事件注册到Selector上
            socketChannel.register(this.selector, SelectionKey.OP_READ);
            // 存储服务端为客户端创建的SocketChannel，为后面的转发消息服务
            this.clientSocketChannels.put(this.getClientName(socketChannel), socketChannel);
            // 通过System.in IO流来创建Scanner
            Scanner scanner = new Scanner(System.in);
            // 收集服务端控制台输入的数据，通过线程池将数据广播给所有客户端SocketChannel
            this.executorService.submit(() -> {
                while (true) {
                    // 该方法会被block住，一直等到服务端控制台有数据输入完为止
                    String sendText = scanner.nextLine();
                    // 将服务端的数据广播给所有客户端
                    transferToOthers(sendText, null);
                }
            });
        // 服务端监听到有数据可以读取，主要是来源于客户端发送的数据
        } else if (selectionKey.isReadable()) {
            // 获取服务端的SocketChannel，然后与客户端进行通信
            // 需要注意的是：当前获取的SocketChannel与ServerSocketChannel是不同的，
            // 这个SocketChannel是通过调用ServerSocketChannel.accept方法创建的（存储在clientSocketChannels集合中）
            SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
            // 清空当前的用来存储读数据的buffer
            readBuffer.clear();
            // 将数据从SocketChannel读入buffer
            int bytes = socketChannel.read(readBuffer);
            if (bytes > 0) {
                // 使得buffer中的数据可读
                readBuffer.flip();
                // 读取buffer中的数据
                String text = String.valueOf(this.charset.decode(readBuffer));
                System.out.println(this.getClientName(socketChannel) + ": " + text);
                // 将客户端发送过来的数据转发给其他客户端
                this.transferToOthers(text, socketChannel);
            }
        }
    }

    /**
     * 将数据发送给其他客户端
     */
    private void transferToOthers(String text, final SocketChannel socketChannel) {
        this.clientSocketChannels.forEach((channelName, channel) -> {
            // 获取之前存储的与服务端建立连接的客户端
            SocketChannel otherSocketChannel = (SocketChannel) channel;
            if (!otherSocketChannel.equals(socketChannel)) {
                // 清空写缓存
                this.writeBuffer.clear();
                // 将数据写入缓存
                this.writeBuffer.put(this.charset.encode(this.getClientName(socketChannel) + ": " + text));
                // 使得缓存中的数据变得可用
                this.writeBuffer.flip();
                try {
                    // 将buffer中的数据写入到其它客户端
                    otherSocketChannel.write(this.writeBuffer);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * 通过SocketChannel生成客户端的名字，用来标识
     */
    private String getClientName(SocketChannel socketChannel) {
        if (socketChannel == null)
            return "[server]";
        Socket socket = socketChannel.socket();
        return "[" + socket.getInetAddress().toString().substring(1) + ":" + socket.getPort() + "]";
    }

    /**
     * 启动服务端程序
     */
    public void start() {
        // 无限循环来轮询所有注册的Channel
        while (true) {
            try {
                // 选择已经准备好的Channel，该方法是会block住的，直到有事件到达
                this.selector.select();
                // 获取所有监听到的事件
                Iterator<SelectionKey> iterator = this.selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    // 找到事件SelectionKey，里面包含了事件相关的所有数据
                    SelectionKey selectionKey = iterator.next();
                    // 如果事件是有效的
                    if (selectionKey.isValid()) {
                        // 处理事件
                        this.work(selectionKey);
                    }
                    // 删除已经处理过的事件
                    iterator.remove();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端代码如下：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
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;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

public class Client {

    public static void main(String[] args) throws IOException {
        new Client().start(); // 客户端程序执行入口
    }

    /**
     * 注册监听的服务的端口，并初始化
     */
    public Client() throws IOException {
        this.serverSocketAddress = new InetSocketAddress("127.0.0.1", 9999);
        this.init();
    }

    /**
     * 服务的Socket地址
     */
    private SocketAddress serverSocketAddress;

    /**
     * 客户端Selector
     */
    private Selector selector;

    /**
     * 字符编码
     */
    private Charset charset = Charset.forName("UTF-8");

    /**
     * 读缓冲区
     */
    private ByteBuffer readBuffer = ByteBuffer.allocate(1024);

    /**
     * 写缓冲区
     */
    private ByteBuffer writeBuffer = ByteBuffer.allocate(4);

    /**
     * 线程池执行客户端发送数据
     */
    private static ExecutorService executorService = Executors.newFixedThreadPool(1, new ThreadFactory() {
        @Override
        public Thread newThread(Runnable runnable) {
            Thread thread = new Thread(runnable);
            thread.setDaemon(true);
            thread.setName("client-sender");
            return thread;
        }
    });

    /**
     * 初始化客户端信息
     */
    private void init() throws IOException {
        // 声明一个客户端SocketChannel
        SocketChannel socketChannel = SocketChannel.open();
        // 设置成非阻塞模式
        socketChannel.configureBlocking(false);
        // 声明一个Selector
        this.selector = Selector.open();
        // 将客户端的SocketChannel的连接事件注册到selector上
        socketChannel.register(this.selector, SelectionKey.OP_CONNECT);
        // 连接服务端
        socketChannel.connect(this.serverSocketAddress);
    }

    /**
     * 处理客户端数据
     */
    private void work(SelectionKey selectionKey) {
        try {
            //  与服务端建立连接
            if (selectionKey.isConnectable()) {
                // 从SelectionKey中获取客户端的ServerSocketChannel
                SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                // 判断连接是否完成
                if (socketChannel.isConnectionPending()) {
                    // 完成连接
                    socketChannel.finishConnect();
                    System.out.println("The connection is successful！");
                    // 通过System.in IO流来创建Scanner
                    Scanner scanner = new Scanner(System.in);
                    // 使用线程池来完成对客户端的控制台数据输入的监听
                    executorService.submit((Runnable) () -> {
                        while (true) {
                            try {
                                // 清空写缓冲区
                                writeBuffer.clear();
                                // 该方法会被block住，一直等到客户端控制台有数据输入完为止
                                String sendText = scanner.nextLine();
                                // 将数据写入写缓冲区
                                writeBuffer.put(charset.encode(sendText));
                                // 使得写缓冲区中的数据可读
                                writeBuffer.flip();
                                // 将数据通过SocketChannel发送到服务端
                                socketChannel.write(writeBuffer);
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    });
                }
                // 注册可读事件，应该当前的SocketChannel与服务端建立连接以后，不需要再监听创建连接的事件
                // 为了复用SocketChannel，将SocketChannel的Read事件注册到Selector
                socketChannel.register(selector, SelectionKey.OP_READ);
            }
            // 可读事件，有从服务器端发送过来的信息，读取输出到控制台上
            else if (selectionKey.isReadable()) {
                // 获取与服务端通信的客户端SocketChannel
                SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                // 清空读缓冲区
                this.readBuffer.clear();
                // 将数据读取到读缓冲区，并将数据输出到客户端控制台
                int count = socketChannel.read(this.readBuffer);
                if (count > 0) {
                    String text = new String(this.readBuffer.array(), 0, count);
                    System.out.println(text);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 启动客户端程序
     */
    public void start() throws IOException {
        // 无限循环，轮询所有监听的SocketChannel
        while (true) {
            // 选择已经准备好的Channel，该方法是会block住的，直到有事件到达
            int events = this.selector.select();
            if (events > 0) {
                // 找到事件SelectionKey，里面包含了事件相关的所有数据
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                // 处理事件
                selectionKeys.forEach(selectionKey -> this.work(selectionKey));
                // 清空已处理的事件
                selectionKeys.clear();
            }
        }
    }
}

总结

• 服务端的ServerSocketChannel是用来监听客户端的连接请求，只有1个且端口固定，主要监听accept事件
• 服务端的SocketChannel是用来和客户端建立数据读写操作通信，数量与客户端的连接数量一致，每个都分配一个随机的端口，主要监听read事件
• 每个客户端有一个SocketChannel，用来和服务端进行通信，主要监听connect事件和read事件，connect事件只会在第一连接时发生，read事件是在每次接收服务端数据时发生
• 服务端和客户端各有一个Selector，用来监听所有的SocketChannel或者ServerSocketChannel中注册的事件，在没有事件发生的时候，Selector.select()会被block住
• 在定义缓冲区的时候要注意缓冲区的大小，如果太小会报BufferOverflowException