java selector

java selector使用select轮询注册到selector中的channel，如果有channel准备好注册的事件，select()返回，返回值为可以操作的channel的个数。通过selector.selectedKeys()返回选中的key的集合。遍历集合中所有的key，判断key的事件，进行相应的处理，并从集合中remove掉。

客户端selector的使用逻辑与服务端selector使用逻辑几乎一致。

Server代码中监听了两个端口8888和8889两个端口，并注册到selector中。读取客户端发送的信息，并发送信息到客户端

Client代码向服务器对应的端口号发送信息，并接收服务器端返回的信息

这里我服务端用了channel+selector客户端直接用的socket，可以发送给服务端信息，但接收服务端信息没有接收到（代码没有贴出来）

 

PS:使用selector+channel可以在一个线程内监听多个channel，下面代码中就监听了两个端口的channel

 

SelectorServer.java

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
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;

/**
 * Created by 58 on 2016/11/28.
 */
public class SelectorServer {
    public static void main(String args[]){
        startServer();
    }
    public static ByteBuffer sendBuffer = ByteBuffer.allocate(1024);
    public static ByteBuffer receiveBuffer = ByteBuffer.allocate(1024);

    public static void startServer(){
        //用两个channel监听两个端口
        int listenPort = 8888;
        int listenPort1 = 8889;
        sendBuffer.put("message from server".getBytes());

        try {
            //创建serverchannel，绑定对应的端口
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            ServerSocket serverSocket = serverSocketChannel.socket();
            InetSocketAddress inetSocketAddress = new InetSocketAddress(listenPort);
            serverSocket.bind(inetSocketAddress);

            //创建第二个channel
            ServerSocketChannel serverSocketChannel1 = ServerSocketChannel.open();
            ServerSocket serverSocket1 = serverSocketChannel1.socket();
            InetSocketAddress inetSocketAddress1 = new InetSocketAddress(listenPort1);
            serverSocket1.bind(inetSocketAddress1);


            //创建selector对象
            Selector selector = Selector.open();

            //设置channel注册到selector中
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            //第二个channel
            serverSocketChannel1.configureBlocking(false);
            serverSocketChannel1.register(selector, SelectionKey.OP_ACCEPT);

            System.out.println("start to listen port: " + listenPort);
            System.out.println("start to listen port: " + listenPort1);

            //监听端口
            while(true){
                int readyChannels = selector.select();
                if(readyChannels == 0)
                    continue;
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectedKeys.iterator();
                while(iterator.hasNext()){
                    SelectionKey selectionKey = iterator.next();
                    dealSelectionKey(selector, selectionKey);

                    iterator.remove();
                }//while
            }//while


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

    public static void dealSelectionKey(Selector selector, SelectionKey selectionKey){
        try{
            //准备好接收新的连接
            if(selectionKey.isAcceptable()){
                ServerSocketChannel serverSocketChannel = (ServerSocketChannel) selectionKey.channel();
                SocketChannel clientSocketChannel = serverSocketChannel.accept();
                clientSocketChannel.configureBlocking(false);
                clientSocketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
                System.out.println("channel is ready acceptable");
            }
            else if(selectionKey.isConnectable()){
                selectionKey.channel().register(selector, SelectionKey.OP_READ);
                System.out.println("channel is connectable.");
            }
            else if(selectionKey.isReadable()){
                //读去客户端内容
                SocketChannel clientSocketChannel = (SocketChannel) selectionKey.channel();
                receiveBuffer.clear();
                clientSocketChannel.read(receiveBuffer);
                selectionKey.interestOps(SelectionKey.OP_WRITE);
                System.out.println("message from client is: " + new String(receiveBuffer.array()));
                System.out.println("Thread id : " + Thread.currentThread().getId());
            }
            else if(selectionKey.isWritable()){
                //向客户端写数据
                SocketChannel clientSocketChannel = (SocketChannel) selectionKey.channel();
                sendBuffer.flip();
                System.out.println("sendBuffer = " + new String(sendBuffer.array()));
                clientSocketChannel.write(sendBuffer);
                selectionKey.interestOps(SelectionKey.OP_READ);
                System.out.println("channle is writable.");
            }//else if
        }catch (Exception e){

        }
    }
}

SelectorClient.java

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

/**
 * Created by 58 on 2016/11/28.
 */
public class SelectorClient {
    public static void main(String args[]){
        work();
    }

    public static void work(){
        int serverPort = 8888;
        ByteBuffer sendBuffer = ByteBuffer.wrap("client message".getBytes());
        ByteBuffer receiveBuffer = ByteBuffer.allocate(1024);
        try {
            //创建通道，设置通道注册到selector中
            SocketChannel socketChannel = SocketChannel.open();
            Selector selector = Selector.open();

            socketChannel.configureBlocking(false);
            socketChannel.register(selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ | SelectionKey.OP_CONNECT);
            socketChannel.connect(new InetSocketAddress("localhost", serverPort));
            int executeTimes = 2;
            //while
            while(executeTimes > 0){
                executeTimes--;
                int reayChannelNum = selector.select();
                if(reayChannelNum == 0){
                    continue;
                }
                Set<SelectionKey> setOfSelectionKey = selector.selectedKeys();
                Iterator<SelectionKey> iterator = setOfSelectionKey.iterator();
                while(iterator.hasNext()){
                    SelectionKey selectionKey = iterator.next();
                    SocketChannel socketChannel1 = (SocketChannel) selectionKey.channel();
                    iterator.remove();
                    if(selectionKey.isConnectable()){
                        if(socketChannel1.isConnectionPending()){
                            socketChannel1.finishConnect();
                            System.out.println("connection complete.");
                            socketChannel1.write(sendBuffer);
                        }
                    }//if isConnectable
                    else if(selectionKey.isReadable()){
                        receiveBuffer.clear();
                        socketChannel1.read(receiveBuffer);
                        receiveBuffer.flip();
                        System.out.println("message from server: " + new String(receiveBuffer.array()));

                    }//else if readable
                    else if(selectionKey.isWritable()){
                        sendBuffer.flip();
                        socketChannel1.write(sendBuffer);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}