相对于非阻塞通信的复杂性，通常客户端并不需要使用非阻塞通信以提高性能，故这里只有服务端使用非阻塞通信方式实现
客户端：
package com.test.client;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.channels.SocketChannel;
import org.apache.log4j.Logger;
import com.test.util.SocketIO;
public class Client {
static Logger logger = Logger.getLogger(Client.class);
private int port = 10000;
private SocketChannel socketChannel;
public Client(){
try {
socketChannel = SocketChannel.open();
InetAddress host = InetAddress.getLocalHost();
InetSocketAddress addr = new InetSocketAddress(host, port);
socketChannel.connect(addr);
logger.debug("***");
logger.debug("client ip:"+socketChannel.socket().getLocalAddress());
logger.debug("client port:"+socketChannel.socket().getLocalPort());
logger.debug("server ip:"+socketChannel.socket().getInetAddress());
logger.debug("server port:"+socketChannel.socket().getPort());
logger.debug("***");
} catch (IOException e) {
e.printStackTrace();
logger.error("Cilent socket establish failed!");
}
logger.info("Client socket establish success!");
}
public void request(String request){
try{
DataInputStream input = SocketIO.getInput(socketChannel.socket());
DataOutputStream output = SocketIO.getOutput(socketChannel.socket());
if(null != request && !request.equals("")){
byte[] bytes = request.getBytes("utf-8");
output.write(bytes);
bytes = new byte[64];
int num = input.read(bytes);
byte[] answer = new byte[num];
System.arraycopy(bytes, 0, answer, 0, num);
if(num > 0){
logger.info("server answer:"+new String(answer,"utf-8"));
}else{
logger.info("No server answer.");
}
}
}catch(Exception e){
e.printStackTrace();
logger.error("client request error");
}finally{
if(null != socketChannel){
try{
socketChannel.close();
}catch(Exception e){
e.printStackTrace();
logger.error("socket close error");
}
}
}
}
public static void main(String[] args){
Client client1 = new Client();
//Client client2 = new Client();
client1.request("your name?");
//client2.request("your name?");
}
}
服务端：
package com.test.server;
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.nio.charset.Charset;
import java.util.Iterator;
import java.util.Set;
import org.apache.log4j.Logger;
public class Server {
static Logger logger = Logger.getLogger(Server.class);
private Selector selector;
private ServerSocketChannel serverSocketChannel;
private int queueNum = 10;
private int bindPort = 10000;
private int step = 0;
private Charset charset = Charset.forName("utf-8");
private ByteBuffer buffer = ByteBuffer.allocate(64);
public Server(){
try{
//为ServerSocketChannel监控接收连接就绪事件
//为SocketChannel监控连接就绪事件、读就绪事件以及写就绪事件
selector = Selector.open();
//作用相当于传统通信中的ServerSocket
//支持阻塞模式和非阻塞模式
serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.socket().setReuseAddress(true);
//非阻塞模式
serverSocketChannel.configureBlocking(false);
//serverSocketChannel.socket()会获得一个和当前信道相关联的socket
serverSocketChannel.socket().bind(new InetSocketAddress(bindPort),queueNum);
//注册接收连接就绪事件
//注册事件后会返回一个SelectionKey对象用以跟踪注册事件句柄
//该SelectionKey将会放入Selector的all-keys集合中，如果相应的事件触发
//该SelectionKey将会放入Selector的selected-keys集合中
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
}catch(Exception e){
e.printStackTrace();
logger.error("Server establish error!");
}
logger.info("Server start up!");
}
public void service() throws Exception{
//判断是否有触发事件
while(selector.select() > 0){
Set selectedKeys = selector.selectedKeys();
Iterator iterator = selectedKeys.iterator();
while(iterator.hasNext()){
SelectionKey selectionKey = iterator.next();
//处理事件后将事件从Selector的selected-keys集合中删除
iterator.remove();
try{
if(selectionKey.isAcceptable()){
this.Acceptable(selectionKey);
}else if(selectionKey.isReadable()){
this.Readable(selectionKey);
}else if(selectionKey.isWritable()){
this.Writable(selectionKey);
}
}catch(Exception e){
e.printStackTrace();
logger.error("event deal exception!");
}
}
}
}
private void Acceptable(SelectionKey selectionKey) throws Exception{
logger.info("accept:"+(++step));
ServerSocketChannel ssc = (ServerSocketChannel)selectionKey.channel();
SocketChannel sc = (SocketChannel)ssc.accept();
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ);
logger.info(selectionKey.hashCode());
}
private void Readable(SelectionKey selectionKey) throws Exception{
logger.info("read:"+(++step));
SocketChannel sc = (SocketChannel)selectionKey.channel();
buffer.clear();
int num = sc.read(buffer);
String request = "";
if(num > 0){
buffer.flip();
request = charset.decode(buffer).toString();
sc.register(selector, SelectionKey.OP_WRITE,request);
}else{
sc.close();
}
logger.info(selectionKey.hashCode()+":"+request);
}
private void Writable(SelectionKey selectionKey) throws Exception{
logger.info("write:"+(++step));
String request = (String)selectionKey.attachment();
SocketChannel sc = (SocketChannel)selectionKey.channel();
String answer = "not supported";
if(request.equals("your name?")){
answer = "server";
}
logger.info(selectionKey.hashCode()+":"+answer);
buffer.clear();
buffer.put(charset.encode(answer));
buffer.flip();
while(buffer.hasRemaining())
sc.write(buffer);
sc.close();
}
public static void main(String[] args) {
Server server = new Server();
try{
server.service();
}catch(Exception e){
e.printStackTrace();
logger.error("Server run exception!");
}
}
}
IO工具类：
package com.test.util;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class SocketIO{
public static DataInputStream getInput(Socket socket) throws IOException{
//接收缓存区大小，socket获取输入流之前设置
socket.setReceiveBufferSize(10);
InputStream input = socket.getInputStream();
return new DataInputStream(input);
}
public static DataOutputStream getOutput(Socket socket) throws IOException{
//发送缓存区大小，socket获取输出流之前设置
socket.setSendBufferSize(10);
OutputStream output = socket.getOutputStream();
return new DataOutputStream(output);
}
}
log4j日志配置文件：
log4j.rootLogger=debug,logOutput
log console out put
log4j.appender.logOutput=org.apache.log4j.ConsoleAppender
log4j.appender.logOutput.layout=org.apache.log4j.PatternLayout
log4j.appender.logOutput.layout.ConversionPattern=%p%d{[yy-MM-dd HH:mm:ss]}[%c] -> %m%n
server端的运行结果：
INFO[13-10-16 11:40:41][com.test.server.Server] -> Server start up!
INFO[13-10-16 11:40:53][com.test.server.Server] -> accept:1
INFO[13-10-16 11:41:14][com.test.server.Server] -> 20469344
INFO[13-10-16 11:41:21][com.test.server.Server] -> read:2
INFO[13-10-16 11:41:37][com.test.server.Server] -> 11688861:your name?
INFO[13-10-16 11:43:00][com.test.server.Server] -> write:3
INFO[13-10-16 11:43:00][com.test.server.Server] -> 11688861:server可以看到readable方法中的SelectionKey和writable方法中的SelectionKey的哈希码是完全相同的，是同一个SelectionKey
SelectionKey是在SocketChannel类或ServerSocketChannel类注册要监控的事件时产生的，这两个类本身并没有register方法，需要查看它们共同父类AbstractSelectableChannel（只有关键代码）：
public abstract class AbstractSelectableChannel
extends SelectableChannel{
......
// Keys that have been created by registering this channel with selectors.
// They are saved because if this channel is closed the keys must be
// deregistered. Protected by keyLock.
private SelectionKey[] keys = null;
public final SelectionKey register(Selector sel, int ops, Object att)
throws ClosedChannelException{
if (!isOpen())
throw new ClosedChannelException();
if ((ops & ~validOps()) != 0)
throw new IllegalArgumentException();
synchronized (regLock) {
if (blocking)
throw new IllegalBlockingModeException();
SelectionKey k = findKey(sel);
if (k != null) {
k.interestOps(ops);
k.attach(att);
}
if (k == null) {
// New registration
k = ((AbstractSelector)sel).register(this, ops, att);
addKey(k);
}
return k;
}
}
private SelectionKey findKey(Selector sel) {
synchronized (keyLock) {
if (keys == null)
return null;
for (int i = 0; i < keys.length; i++)
if ((keys[i] != null) && (keys[i].selector() == sel))
return keys[i];
return null;
}
}
void removeKey(SelectionKey k) { // package-private
synchronized (keyLock) {
for (int i = 0; i < keys.length; i++)
if (keys[i] == k) {
keys[i] = null;
keyCount--;
}
((AbstractSelectionKey)k).invalidate();
}
}
......
}ServerSocketChannel和Socketchannel向Selector中注册了特定事件，Selector就会监控这些事件是否发生。ServerSocketChannel和Socketchannel都为AbstractSelectableChannel类的子类，AbstractSelectableChannel类的register方法负责注册事件，该方法会返回一个SelectionKey对象，该对象用于跟踪被注册事件
public abstract class SelectionKey {
protected SelectionKey() { }
public abstract SelectableChannel channel();
public abstract Selector selector();
......
}一个Selector对象中包含了3种类型的键集（即SelectionKey集合，SelectionKey在以下部分被称为“键”）
1，all-keys:所有注册至该Selector的事件键集（selector.keys()）
2，selected-keys:相关事件已经被Selector捕获的键集（selector.selectedKeys()）
3，cancel-keys:已被取消的键集（无法访问该集合）
selected-keys和cancel-keys都为all-keys的子集，对于一个新建的Selector，这3个键集都为空
注册事件时会将相应的SelectionKey加入Selector的all-keys键集中
取消SelectionKey或者关闭了SelectionKey相关联的Channel，则会将相应的SelectionKey加入cancel-keys键集中
当执行选择器的选择操作时（selector.select()，对于选择器来说，这个方法应该是相当重要的）:
1,将cancel-keys中的每个SelectionKey从3个键集中移除（如果存在的话），并注销SelectionKey所关联的Channel，cancel-keys键集变为空集。
2,如果监控的事件发生，Selector会将相关的SelectionKey加入selected-keys键集中
以下为对源代码的分析、推测：
Selector作为选择器，保存了所有的Selectionkey（注册的，取消的，触发的），通过上面的AbstractSelectableChannel类的源代码，发现Channel本身也保存了一个自身关联的SelectionKey数组，这看起来是完全没有必要的，但是仔细看一下register方法，能看出些许端倪：
Selector本身维护了3个集合，all-keys，selected-keys和cancel-keys，频繁的注册操作、取消注册将会导致这3个集合频繁的变化，伴随频繁变化的是频繁的加锁，这会严重的降低Selector的性能，毕竟一个Selector会被多个Channel作为选择器使用，本身非阻塞的实现方式就是提高性能的一种解决方式
当注册新的事件时，如果存在该通道相关的SelectionKey，则更新该SelectionKey所关注的事件以及其携带的附加信息，如果不存在，则添加新的SelectionKey
这样做的好处是，比起删除以前的SelectionKey，添加新的SelectionKey，修改SelectionKey所关注的事件以及其携带的附加信息显然是更好的选择，毕竟不需要修改Selector所维护的键集，当然也不需要频繁加锁（通过查看Selector类的api，SelectionKey并不是thread-safe的，显然并没有加锁，但是并没有什么问题），能够提供更好的性能
总之，SelectionKey的哈希码会重复是很正常的，毕竟不是单纯的注册时新建、触发后删除方式，java实现时进行了优化