TCP java nio code TBD

public class NIOServer {
//通道管理器
private Selector selector;

/**
* 获得一个ServerSocket通道，并对该通道做一些初始化的工作
* @param port  绑定的端口号
* @throws IOException
*/
public void initServer(int port) throws IOException {
// 获得一个ServerSocket通道
ServerSocketChannel serverChannel = ServerSocketChannel.open();
// 设置通道为非阻塞
serverChannel.configureBlocking(false);
// 将该通道对应的ServerSocket绑定到port端口
serverChannel.socket().bind(new InetSocketAddress(port));
// 获得一个通道管理器
this.selector = Selector.open();
//将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，
//当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
}

<pre name="code" class="html">public static void main(String[] args) throws IOException, InterruptedException {
NIOServer server = new NIOServer();
server.initServer(8000);
//server.listen();
while(true){

System.out.println("select " + server.selector.select() + "event");
Iterator ite = server.selector.selectedKeys().iterator();  <strong><span style="color:#FF0000;">//服务端一旦select 变会向客户端 发送 accpct 事件，客户端必须要finish，客户端的
//selector 才会返回0 阻塞（正常），不然会想select jdk描述中一样认为 ready-operation sets were updated 不断返回1， 完成finish后 会不断返回0 ？ 必须添加个感兴
//趣 时间后，才会block住 才认为状态没updated, 如果客户端注册的是 读事件，服务器通过channel write了，客户端这边 通过channel 读到了buffer中但是因为是nonblock的读
//可能每次只读了部分 如1000个字节只读了10个字节，那么selector 会认为那个 read事件 只是被updated 还没被消化 还会返回1 ，直到数据读完 才block住，也可以写while直接用
//channel 读完这个 read事件</span></strong>

 while (ite.hasNext()) {
SelectionKey key = (SelectionKey) ite.next();
// 删除已选的key,以防重复处理
ite.remove();
// 客户端请求连接事件
if (key.isAcceptable()) {
System.out.println("ssssssssss");
//Thread.sleep(5000000);
System.out.println("yyyyy");
ServerSocketChannel serverch = (ServerSocketChannel) key
.channel();

// 获得和客户端连接的通道
SocketChannel channel = serverch.accept();
// 设置成非阻塞
System.out.println("debug1：" +channel.socket().getPort());
channel.configureBlocking(false);
String msg = "jjjjjjjjjjjj";
ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes());
channel.write(outBuffer);// 将消息回送给客户端
}
}
}

//在这里可以给客户端发送信息哦
//channel.write(ByteBuffer.wrap(new String("hello chickens").getBytes()));
//在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
//channel.register(this.selector, SelectionKey.OP_READ);

}

}

客户端

public class NIOClient {
// 通道管理器
private Selector selector;

/**
* 获得一个Socket通道，并对该通道做一些初始化的工作
*
* @param ip
*            连接的服务器的ip
* @param port
*            连接的服务器的端口号
* @throws IOException
*/
public void initClient(String ip, int port) throws IOException {
// 获得一个Socket通道
SocketChannel channel = SocketChannel.open();
// 设置通道为非阻塞
channel.configureBlocking(false);
// 获得一个通道管理器
this.selector = Selector.open();

// <strong><span style="color:#FF0000;">客户端连接服务器,其实方法执行并没有实现连接，需要在listen（）方法中调,用channel.finishConnect();才能完成连接，才能将 select的connect事件消化，否则会
//一直返回1，且状态属于updated</span></strong>
channel.connect(new InetSocketAddress(ip, port));
// 将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_CONNECT事件。
channel.register(selector, SelectionKey.OP_CONNECT);
}

public static void main(String[] args) throws IOException,
            InterruptedException {
        NIOClient client = new NIOClient();
        client.initClient("localhost", 8000);
        while (true) {
            System.out.println("clientselect " + client.selector.select()
                    + "event");
            Iterator ite = client.selector.selectedKeys().iterator();
            while (ite.hasNext()) {
                SelectionKey key = (SelectionKey) ite.next();
                // 删除已选的key,以防重复处理
                ite.remove();
                // 客户端请求连接事件
                Thread.sleep(1000);
                if (key.isConnectable()) {

                    System.out.println("connectable event");
                    SocketChannel channel = (SocketChannel) key.channel();
                    // 如果正在连接，则完成连接
                    if (channel.isConnectionPending()) {
                        channel.finishConnect();
                        channel.register(client.selector, SelectionKey.OP_READ);// 加了一个稳定的注册时间它就不返回0了
                    }
                    // System.out.println("debug1："
                    // +channel.socket().getLocalPort());
                    // 获得和客户端连接的通道
                    // SocketChannel channel = serverch.accept();
                    // 设置成非阻塞
                    // channel.configureBlocking(false);
                } else if (key.isReadable()) {
                    SocketChannel channel = (SocketChannel) key.channel();
                    // 创建读取的缓冲区
                    ByteBuffer buffer = ByteBuffer.allocate(1010);
                    channel.read(buffer);
                    byte[] data = buffer.array();
                    String msg = new String(data).trim();
                    System.out.println("client收到信息：" + msg);
                }
            }

        }

        // client.listen();
    }

简单说下 nio 和 老io 除了reactor的区别

同步的 socket tcp三次握手比（ 1.socketclient 连接  2.socket服务端接受发送 3.socketclient read服务端发送的信息  这三个步骤是阻塞的 阻塞在read上。）

而nio 中， channel client不用阻塞的去read， 可以采用 selecter去 select 到READ请求， 再从selectedKeys中拿到 对应的channel 去读数据。

  其实这边channel 和
hadoop rpc 异步   的call 设计的比较像




TBD