转：JDK1.4非阻塞套接字API概述

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。

[@more@]

非阻隔套接字允许在通道上做输入/输出操作而不用阻塞该通道的进程。本文中我将讨论异步高性能读/写操作和翻转上下设计和开发基于接口的应用程序的技巧。

　　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的容量。

　　要想读取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方法来设置它。我们来看下面的例子：

// 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:服务器端可写。

　　通常一个表示接受的关键字创建在服务器端。事实上，这种关键字仅仅通知一下服务器端客户端请求连接。在这种环境下，正如你通过算法得到的结论一样，服务器端个性化套接字通道和连接这个通道到选择器以便进行读/写操作。从这一刻起，当接受客户端读或写操作时，选择器将为客户端创建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）
　　为了检验编制的服务器端能否以非阻隔的方法工作正常，我将实现一个客户端以在套接字通道上连续的写字符串“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应用程序的重要的一大步。看完这篇文章，依靠非阻隔套接字技术你可以写一个基于非阻隔套接字的应用程序而不用手工来处理多线程。

http://www.yesky.com/90/1746090.shtml

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/220284/viewspace-1023679/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/220284/viewspace-1023679/