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();
         }
     }
 }