tcp nio 远程主机强迫关闭了一个现有的连接

import java.io.IOException;

import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.SocketAddress;
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 NIOServer implements Runnable {

/*标识数字*/
private  int flag = 0;
/*缓冲区大小*/
private  int BLOCK = 4096;
/*接受数据缓冲区*/
private  ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);
/*发送数据缓冲区*/
private  ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);
private  Selector selector;

public NIOServer(int port){
try{
// 打开服务器套接字通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
// 服务器配置为非阻塞
serverSocketChannel.configureBlocking(false);
// 检索与此通道关联的服务器套接字
ServerSocket serverSocket = serverSocketChannel.socket();
// 进行服务的绑定
serverSocket.bind(new InetSocketAddress(port));
// 通过open()方法找到Selector
selector = Selector.open();
// 注册到selector，等待连接
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("Server Start----8888:");
}catch(Exception e){
e.printStackTrace();
}
}

// 监听
public void run() {
try {
while (true) {
// 选择一组键，并且相应的通道已经打开
selector.select();
// 返回此选择器的已选择键集。
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
SelectionKey selectionKey = iterator.next();
iterator.remove();
try{
handleKey(selectionKey);

}catch(IOException e){
e.printStackTrace();
//selectionKey.cancel();
break;
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}

// 处理请求
private void handleKey(SelectionKey selectionKey) throws IOException {
// 接受请求
ServerSocketChannel server = null;
SocketChannel client = null;
SocketAddress clientaddr = null;
String receiveText;
String sendText;
int count=0;

// 测试此键的通道是否已准备好接受新的套接字连接。

if (selectionKey.isAcceptable()) {
// 返回为之创建此键的通道。
server = (ServerSocketChannel) selectionKey.channel();
// 接受到此通道套接字的连接。
// 此方法返回的套接字通道（如果有）将处于阻塞模式。
client = server.accept();
clientaddr=client.socket().getRemoteSocketAddress();
System.out.printf("+++++++++++服务器端接受客户端[%s]连接!+++++++++++ \n",clientaddr);
// 配置为非阻塞
client.configureBlocking(false);
// 注册到selector，等待连接
client.register(selector, SelectionKey.OP_READ);
} else if (selectionKey.isReadable()) {

// 返回为之创建此键的通道。
client = (SocketChannel) selectionKey.channel();
clientaddr=client.socket().getRemoteSocketAddress();
//将缓冲区清空以备下次读取
receivebuffer.clear();

//读取服务器发送来的数据到缓冲区中
count = client.read(receivebuffer);
if (count > 0) {
receiveText = new String( receivebuffer.array(),0,count);
System.out.printf("服务器端接受客户端[%s]数据:\n%s",clientaddr,receiveText);
client.register(selector, SelectionKey.OP_WRITE);
}

} else if (selectionKey.isWritable()) {
//将缓冲区清空以备下次写入
sendbuffer.clear();
// 返回为之创建此键的通道。
client = (SocketChannel) selectionKey.channel();
sendText="message from server--" + flag++;
//向缓冲区中输入数据
sendbuffer.put(sendText.getBytes());
//将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位
sendbuffer.flip();
//输出到通道
client.write(sendbuffer);
System.out.println("服务器端向客户端发送数据--："+sendText);
client.register(selector, SelectionKey.OP_READ);
}
}

/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
int port = 8888;
NIOServer server = new NIOServer(port);
server.run();
}
}

上面是从网上摘录的Java NIO TCP 的一个server程序，用客户端的NIO TCP与之连接的时候，只要客户端断开连接，服务器端就会报出“远程主机强迫关闭了一个现有的连接”的错误，并且中断服务器端程序。经过查阅之后发现，得知“OP_READ
事件不仅仅只有可读时才触发，当channel中数据读完远程的另一端被关闭有一个错误的pending都会触发OP_READ事件"!

解决办法：在selectionKey.isReadable()中加入错误捕捉机制，即：

if (selectionKey.isReadable()) {

try {

// 返回为之创建此键的通道。

client = (SocketChannel) selectionKey.channel();

clientaddr=client.socket().getRemoteSocketAddress();

//将缓冲区清空以备下次读取

receivebuffer.clear();

//读取服务器发送来的数据到缓冲区中

count = client.read(receivebuffer);

if (count > 0) {

receiveText = new String( receivebuffer.array(),0,count);

System.out.printf("服务器端接受客户端[%s]数据:\n%s",clientaddr,receiveText);

client.register(selector, SelectionKey.OP_WRITE);

}

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

selectionKey.cancel(); //取消selectionKey

}

就可以捕获异常，使服务器程序不会因为某一个客户端的断开而中断.