Selector示例

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

仅用单个线程来处理多个Channel的好处是：只需要更少的线程来处理多个通道。

服务端示例

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

public class selector
{
    public static void main(String[] args) throws IOException
    {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress("127.0.0.1", 8000));
        serverSocketChannel.configureBlocking(false);

        Selector selector = Selector.open();
        // 创建一个ServerSocketChannel，和一个Selector，并且把这个server channel 注册到 selector上
        // 这个channel 所感觉兴趣的事件是 SelectionKey.OP_ACCEPT。
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        ByteBuffer readBuff = ByteBuffer.allocate(1024);
        ByteBuffer writeBuff = ByteBuffer.allocate(128);
        writeBuff.put("received".getBytes());
        writeBuff.flip();

        while (true){
            //使用 select 方法阻塞住线程，当select 返回的时候，线程被唤醒。
            int nReady = selector.select();
            // 通过selectedKeys方法得到所有可用channel的集合。
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> it = keys.iterator();
            while (it.hasNext()){
                SelectionKey key = it.next();
                it.remove();
                if (key.isAcceptable()){
                    // 如果其中channel 上有连接到达，就接受新的连接，然后把这个新的连接也注册到selector中去。
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    //socket默认是blocking的
                    socketChannel.configureBlocking(false);
                    // 声明这个channel只对读操作感兴趣。
                    socketChannel.register(selector, SelectionKey.OP_READ);
                }
                //如果有channel是读，那就把数据读出来，并且把它感兴趣的事件改成写。
                else if (key.isReadable()){
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    readBuff.clear();
                    socketChannel.read(readBuff);

                    readBuff.flip();
                    System.out.println("received : " + new String(readBuff.array()));
                    key.interestOps(SelectionKey.OP_WRITE);
                }
                //如果是写，就把数据写出去，并且把感兴趣的事件改成读。
                else if (key.isWritable()) {
                    writeBuff.rewind();
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    socketChannel.write(writeBuff);
                    key.interestOps(SelectionKey.OP_READ);
                }
            }
        }
    }
}

客户端示例：

import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class Client
{
    public static void main(String[] args) throws IOException
    {
        Socket socket = new Socket("127.0.0.1", 8000);
        //调用connect()方法建立连接，也可以直接调用Socket中的方法
        OutputStream out= socket.getOutputStream();
        Writer writer = new OutputStreamWriter(out, "ASCII");
        writer.write("123");
        writer.flush();

        InputStream in = socket.getInputStream();
        Reader reader = new InputStreamReader(in, "ASCII");
        int c = reader.read();
        while (c != -1){
            System.out.print((char)c);
            c = reader.read();
        }
        socket.close();
    }
}

输出

服务端：

received : 123      

客户端：

received