JDK1.4非阻塞套接字API概述
副标题#e#
J2SE 1.4版引入了非阻隔套接字（Nonblocking sockets）,它答允在网络通信应用措施和没有阻隔的历程中利用套接字。本文将具体先容什么长短阻隔套接字（Nonblocking sockets）及其事情道理和用途。
从Java 1.4起，措施员便能用一组新的API来举办I/O操纵。这是JSR 51项目标功效，自2000年1月的Java 1.4 beta版，措施员便可以利用JSR 51了。在Java 1.4中增加了一些很是重要的新技能来处理惩罚诸如在文件和套接字长举办高机能的读/写操纵，正规表达式，译码/编码字符集，内存映射和文件锁定。在这篇文章中，我们将接头一个非凡的新API――New I/O API: Nonblocking sockets。
非阻隔套接字答允在通道上做输入/输出操纵而不消阻塞该通道的历程。本文中我将接头异步高机能读/写操纵和翻转上下设计和开拓基于接口的应用措施的能力。
Java开拓者也许会问，为什么先容一种新的技能来处理惩罚套接字？Java 1.3.x的套接字又有哪些问题？假设实现处事器端接管差异的客户端的毗连。同样，假设客户端能支持处理惩罚同步的多请求。利用Java 1.3.x,开拓这样的处事器端有两种差异的选择：
●实现多线程处事为每个毗连用户处理惩罚线程。
●利用外部第三方模块。
这两种要领都可以实现，可是假如合用第一种要领――整个线程打点方案，包罗相关并发性和斗嘴问题――都需要靠措施员来处理惩罚。第二个方案也许耗费更大，且使应用措施依靠“non－JDK”的外部模块。依靠非阻隔套接字，你能实现非阻隔的处事无需直接打点线程可能回收外部模块。
Buffer
在我们思量非阻隔套接字以前，不得不耗费一些时间在一个新的Java 1.4的类：java.nio.Buffer上。一个Buffer实例只是原始数据的一个有限的容器。称其有限是因为它只能包括有限数量的字节；换句语说，它不是一个像Vector或是ArrayList一样的容器，后两者从理论上说是没有限度的。别的，一个Buffer实例仅能包括属于Java的根基数据范例。譬喻：int,char,double,Boolean,等等。
Buffer类是一个抽象类，它有7个子种别离对应于七种根基的数据范例：
●ByteBuffer
●CharBuffer
●DoubleBuffer
●FloatBuffer
●IntBuffer
●LongBuffer
●ShortBuffer
在非阻隔套接字编程中，凡是所有新 I/O系统能事情的情况中，极其重要的是办理Buffer工具如何事情。这是因为新套接字通道利用Buffer工具通过网络来传送数据。
你可以利用以下静态要领（即类要领）来建设一个新的Buffer实例：allocate,allocateDirect,wrap。在下面的例子中，三个Buffer工具将用三种差异的要领来实例化。
ByteBuffer buffer1 = ByteBuffer.allocate(1024);
ByteBuffer buffer2 = ByteBuffer.allocateDirect(1024);
ByteBuffer buffer3 = ByteBuffer.wrap(new String("hello").getBytes());
这段代码的前两行建设了两个ByteBuffer工具，它们都包括1024个字节。allocate和allocateDirect要领都做了沟通的事情，差异的是第二个要领直接利用操纵系统来分派Buffer。从而它将提供更快的会见速度。不幸的是，并非所有的虚拟机都支持这种直接分派的要领。第三行利用wrap要领。它建设了一个ByteBuffer工具，包括的字节由字符串“hello”构成。
Buffer工具的浸染或多或少的与流的浸染相似。“当前位置（current position）”是一个极其重要的观念，它计较出你将要处理惩罚的Buffer工具的适当的位置。在任何时候，一个Buffer工具都有一个当前位置指向某一项。之后，每一次读或写操纵城市自动的将当前位置指向Buffer中的下一项。
你可以用put要领写入一些数据到Buffer中：
// Writing on a buffer
IntBuffer buffer = IntBuffer.allocate(10);
for (int i=0; i < buffer.capacity(); i++) {
buffer.put(i);
}
这段代码建设了一个包括10个整型值的Buffer，然后将数字0到9放入到Buffer中。同时你可以看到，我利用了capacity要领来得到Buffer的容量。
#p#副标题#e#
要想读取Buffer的内容，你可以用如下要领来处理惩罚：
// Reading from a buffer
buffer.position(0);
while (buffer.hasRemaining()) {
int i = buffer.get();
System.out.println("i="+i);
}
挪用position要领，你能配置当前位置为0；即Bufferr的起始位置。当在当前位置和limit值之间有元素时，hasRemaining要领返回true；直到超出这个范畴时，这个要领将返回flase。while轮回中的代码挪用get要领读取各项，并同时显示在节制台上。
领略Buffer的limit和capacity这两个值之间的区别是十分重要的。Capacity是某个Buffer工具所能包括的项数的最大值。Limit是在0到capacity之间的一个值，它暗示一个限度，可以利用limit可能flip要领来配置它。我们来看下面的例子：
#p#分页标题#e#
// Sample of using flip
buffer.position(5);
buffer.flip();
while (buffer.hasRemaining()) {
int i = buffer.get();
System.out.println("i="+i);
}
当前位置被position要领配置成5。Flip要领举办如下操纵：先将配置limit为当前位置的值，即5；然后再配置当前位置的值为0。因此，从此的while轮回就只能扫描到前5个元素了，因为flip要领配置了新的limit值，即为5。从而，数字0，1，2，3，4将被显示出来。
另一个重要的Buffer类的要领是clear，它将配置position为0并配置limit为Buffer的容量值。根基上，clear要领消除这之前flip（或limit）要领发生的影响。思量下例：
// Sample of using clear
buffer.clear();
while (buffer.hasRemaining()) {
int i = buffer.get();
System.out.println("i="+i);
}
这段代码将显示数字0到9，而与Buffer的当前位置和limit值无关。
非阻隔（Nonblocking）体系布局
在这一部门，我将从理论的角度上来表明非阻隔体系的布局及其事情道理。这部“喜剧（虽然，假如你喜欢的话也可以称做戏剧）”的“人物”如下：
●处事器：吸收请求的应用措施。
●客户：一组向处事器端发出请求的应用措施。
●套接字通道：客户端与处事器端之间的通信通道。它能识别处事器端的ＩＰ地点和端标语。数据以Buffer中元素的形式通过套接字通道传送。
●选择器：所有非阻隔技能的主要工具。它监督着已注册的套接字通道，并序列化处事器需要应答的请求。
●要害字：选择器用来对工具的请求举办排序。每个要害字代表一个单独的客户端子请求并包括识别客户端和请求范例的信息。
图一：利用非阻隔端口体系的布局图。
图1：非阻隔端口布局
你大概留意到，客户端应用措施同时执行对处事器端的请求，选择器将其会合起来，建设要害字，然后将其发送至处事器端。这看起来像是阻隔（Blocking）体系，因为在一按时间内只处理惩罚一个请求，但事实并非如此。实际上，每个要害字不代表从客户端发至处事器端的整个信息流，仅仅只是一部门。我们不要忘了选择器能支解那些被要害字标识的子请求里的数据。因此，假如有更多持续地数据发送至处事器端，那么选择器就会建设更多的按照时间共享计策（Time-sharing policy）来举办处理惩罚的要害字。强调一下，在图一中要害字的颜色与客户端的颜色相对应。
处事器端非阻隔（Server Nonblocking）
我以前的部门先容过的实体都有与其相当的Java实体。客户端和处事器端是两个Java应用措施。套接字通道是SocketChannel类的实例，这个类答允通过网络传送数据。它们能被Java措施员看作是一个新的套接字。SocketChannel类被界说在java.nio.channel包中。
选择器是一个Selector类的工具。该类的每个实例均能监督更多的套接字通道，进而成立更多的毗连。当一些有意义的事产生在通道上（如客户端试图毗连处事器端或举办读/写操纵），选择器便会通知应用措施处理惩罚请求。选择器会建设一个要害字，这个要害字是SelectionKey类的一个实例。每个要害字都生存着应用措施的标识及请求的范例。个中，请求的范例可以是如下之一：
●实验毗连(客户端)
●实验毗连(处事器端)
●读取操纵
●写入操纵
一个通用的实现非阻隔处事器的算法如下：
create SocketChannel;
create Selector
associate the SocketChannel to the Selector
for(;;) {
waiting events from the Selector;
event arrived; create keys;
for each key created by Selector {
check the type of request;
isAcceptable:
get the client SocketChannel;
associate that SocketChannel to the Selector;
record it for read/write operations
continue;
isReadable:
get the client SocketChannel;
read from the socket;
continue;
isWriteable:
get the client SocketChannel;
write on the socket;
continue;
}
}
根基上，处事器端的实现是由选择器期待事件和建设要害字的无限轮回构成的。按照要害字的范例，实时的执行操纵。要害字存在以下4种大概的范例。
Acceptable: 相应的客户端要求毗连。
Connectable:处事器端接管毗连。
Readable:处事器端可读。
Writeable:处事器端可写。
#p#分页标题#e#
凡是一个暗示接管的要害字建设在处事器端。事实上，这种要害字仅仅通知一下处事器端客户端请求毗连。在这种情况下，正如你通过算法获得的结论一样，处事器端本性化套接字通道和毗连这个通道到选择器以便举办读/写操纵。从这一刻起，当接管客户端读或写操纵时，选择器将为客户端建设Readable或Writeable要害字。从而，处事器端将截取这些要害字并执行正确的行动。
此刻，你可以用下面这个推荐算法和Java语言写处事器端了。用这种要领能乐成的建设套接字通道，选择器，和套接字－选择器注册（socket-selector registration）。
// Create the server socket channel
ServerSocketChannel server = ServerSocketChannel.open();
// nonblocking I/O
server.configureBlocking(false);
// host-port 8000
server.socket().bind(new java.net.InetSocketAddress(host,8000));
System.out.println("Server attivo porta 8000");
// Create the selector
Selector selector = Selector.open();
// Recording server to selector (type OP_ACCEPT)
server.register(selector,SelectionKey.OP_ACCEPT);
这个静态（static）open类要领建设了一个SocketChannel类的实例。configureBlocking(false)挪用配置通道为非阻隔。通过bind要领成立随处事器端的毗连。字符串“host”代表处事器的IP地点，8000是通信套接字。你可以挪用你可以挪用Selector类的静态（static）open要领建设选择器。最后，register要领用来毗连选择器和套接字通道。
第二个参数代表注册的范例。在这个例子中，我们利用OP_ACCEPT，意思是选择器仅能陈诉客户端试图实验毗连处事器端。其他大概的选项是：OP_CONNECT，在客户端下利用；OP_READ; 和OP_WRITE
用Java语言描写的无限for轮回的代码如下：
// Infinite server loop
for(;;) {
// Waiting for events
selector.select();
// Get keys
Set keys = selector.selectedKeys();
Iterator i = keys.iterator();
// For each keys...
while(i.hasNext()) {
SelectionKey key = (SelectionKey) i.next();
// Remove the current key
i.remove();
// if isAccetable = true
// then a client required a connection
if (key.isAcceptable()) {
// get client socket channel
SocketChannel client = server.accept();
// Non Blocking I/O
client.configureBlocking(false);
// recording to the selector (reading)
client.register(selector, SelectionKey.OP_READ);
continue;
}
// if isReadable = true
// then the server is ready to read
if (key.isReadable()) {
SocketChannel client = (SocketChannel) key.channel();
// Read byte coming from the client
int BUFFER_SIZE = 32;
ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
try {
client.read(buffer);
}
catch (Exception e) {
// client is no longer active
e.printStackTrace();
continue;
}
// Show bytes on the console
buffer.flip();
Charset charset=Charset.forName("ISO-8859-1");
CharsetDecoder decoder = charset.newDecoder();
CharBuffer charBuffer = decoder.decode(buffer);
System.out.print(charBuffer.toString());
continue;
}
}
}
轮回的第一行是挪用select要领，它会阻塞历程执行并期待选择器上记录的事件。在这段代码中，套接字通道由处事器变量指代。实际上，处事器端不是一个SocketChannel工具，可是一个ServerSocketChannel工具。它象SocketChannel一样是SelectableChannel类的一般化，凡是用于处事器端的应用措施。
选择器期待的事件是客户端实验毗连。当这样的操纵呈现时，处事器端的应用措施便得到一个由选择器建设的要害字和查抄每个要害字的范例。你也许留意到，当一个要害字被处理惩罚时，它不得不挪用remove要领从这组要害字中被移出。假如这个要害字的范例是可接管的（isAcceptable()=true），那么处事器端便通过挪用accept要领来查找客户端套接字通道，配置它为非阻隔，并将OP_READ选项把它挂号进选择器中。我们也可以利用OP_WRITE 可能是OP_READ|OP_WRITE选项，但为了简朴，我实现的处事器端仅仅能从通道中读取，不能进入写入操纵。
客户端套接字通道此刻已经挂号入选择器并可举办读取操纵。从而，当客户端在套接字通道上写数据时，选择器将通知处事器端应用措施这里有一些数据读。跟着可读要害字的建设，从而isReadable()=true。在这个例子中，应用措施从套接字通道上读取数据利用的是32个字节的ByteBuffer，字节译码利用的是ISO-8859-1编码法则，同时读取的数据也会显示在处事器端的节制台上。
客户端非阻隔（Client Nonblocking）
#p#分页标题#e#
为了检讨体例的处事器端可否以非阻隔的要领事情正常，我将实现一个客户端以在套接字通道上持续的写字符串“Client XXX”，这里的“XXX”是呼吁行所通报的参数。譬喻，当客户端运行的呼吁行的参数是89时，处事器端的节制台上就会显示“Client 89 Client 89 Client 89 Client 89 …”。假如其它的客户端开始的参数是92时会产生些什么呢？假如处事器端已阻隔，任何工作都不会产生；处事器端照旧显示持续的字符串“Client 89”。自从我们的处事器利用了非阻隔套接字，那么节制台就会显示下面这样的字符串："Client 89 Client 89 Client 92 Client 89 Client 92 Client 92 Client 89 Client 89 …"，这意味着在套接字通道上的读/写操纵并不阻塞处事器应用措施的执行。
这里有一段客户端应用措施的代码：
// Create client SocketChannel
SocketChannel client = SocketChannel.open();
// nonblocking I/O
client.configureBlocking(false);
// Connection to host port 8000
client.connect(new java.net.InetSocketAddress(host,8000));
// Create selector
Selector selector = Selector.open();
// Record to selector (OP_CONNECT type)
SelectionKey clientKey = client.register(selector, SelectionKey.OP_CONNECT);
// Waiting for the connection
while (selector.select(500)> 0) {
// Get keys
Set keys = selector.selectedKeys();
Iterator i = keys.iterator();
// For each key...
while (i.hasNext()) {
SelectionKey key = (SelectionKey)i.next();
// Remove the current key
i.remove();
// Get the socket channel held by the key
SocketChannel channel = (SocketChannel)key.channel();
// Attempt a connection
if (key.isConnectable()) {
// Connection OK
System.out.println("Server Found");
// Close pendent connections
if (channel.isConnectionPending())
channel.finishConnect();
// Write continuously on the buffer
ByteBuffer buffer = null;
for (;;) {
buffer =
ByteBuffer.wrap(
new String(" Client " + id + " ").getBytes());
channel.write(buffer);
buffer.clear();
}
}
}
}
也许，客户端应用措施的布局让你回想起处事器端应用措施的布局。然而，这里也有很多差异的处所。套接字通道利用OP_CONNECT选项毗连到选择器上，意思是当处事器接管毗连时选择器将不得不通知客户端，这个轮回不是无穷的。While轮回的条件是：
while (selector.select(500)> 0)
意思是客户端实验毗连，最大时长是500毫秒；假如处事器端没有应答，selete要领将返回0，因为在通道上的处事器没有激活。在轮回里，处事器端检测要害字是否可毗连。在这个例子中，假如有一些不确定的毗连，客户端就封锁那些不确定的毗连，然后写入字符串“Client”后头接着从呼吁行参数中带来的变量ID。
结论
新的Java1.4 I/O体系是实现快速，机动和可进级的Java应用措施的重要的一大步。看完这篇文章，依靠非阻隔套接字技能你可以写一个基于非阻隔套接字的应用措施而不消手工来处理惩罚多线程。
