运用异步输入输出流编写Socket进程通信

同步？异步输入输出机制的引入
在Merlin之前,编写Socket程序是比较繁琐的工作.因为输入输出都必须同步.这样,对于多客户端客户/ 服务器模式,不得不使用多线程.即为每个连接的客户都分配一个线程来处理输入输出.由此而带来的问题是可想而知的.程序员不得不为了避免死锁,线程安全等 问题,进行大量的编码和测试.很多人都在抱怨为什么不在Java中引入异步输入输出机制.比较官方的解释是,任何一种应用程序接口的引入,都必须兼容任何 操作平台.因为Java是跨平台的.而当时支持异步输入输出机制的操作平台显然不可能是全部.自Java 2 Platform以后,分离出J2SE,J2ME,J2EE三种不同类型的应用程序接口,以适应不同的应用开发.Java标准的制订者们意识到了这个问 题,并且支持异步输入输出机制的操作平台在当今操作平台中处于主流地位.于是,Jdk(J2SE) 的第五次发布中引入了异步输入输出机制.

以前的Socket进程通信程序设计中,一般客户端和服务器端程序设计如下：

服务器端：
   //服务器端监听线程
   while (true) {
               .............
               Socket clientSocket;
               clientSocket = socket.accept(); //取得客户请求Socket，如果没有//客户请求连接，线程在此处阻塞
               //用取得的Socket构造输入输出流
               PrintStream os = new PrintStream(new
               BufferedOutputStream(clientSocket.getOutputStream(),
               1024), false);
               BufferedReader is = new BufferedReader(new
               InputStreamReader(clientSocket.getInputStream()));
               //创建客户会话线程,进行输入输出控制，为同步机制
               new ClientSession();
               .......
                }



客户端：
  ............
  clientSocket = new Socket(HOSTNAME, LISTENPORT);//连接服务器套接字
  //用取得的Socket构造输入输出流
  PrintStream os = new PrintStream(new
               BufferedOutputStream(clientSocket.getOutputStream(),
               1024), false);
               BufferedReader is = new BufferedReader(new
               InputStreamReader(clientSocket.getInputStream()));
  //进行输入输出控制
   .......



以 上代码段只是用同步机制编写Socket进程通信的一个框架，实际上要考虑的问题要复杂的多（有兴趣的读者可以参考我的一篇文章《Internet 实时通信系统设计与实现》）。将这样一个框架列出来，只是为了与用异步机制实现的Socket进程通信进行比较。下面将介绍使用异步机制的程序设计。

用异步输入输出流编写Socket进程通信程序
在Merlin 中加入了用于实现异步输入输出机制的应用程序接口包：java.nio（新的输入输出包，定义了很多基本类型缓冲(Buffer)）， java.nio.channels(通道及选择器等，用于异步输入输出)，java.nio.charset（字符的编码解码）。通道 (Channel)首先在选择器(Selector)中注册自己感兴趣的事件，当相应的事件发生时，选择器便通过选择键(SelectionKey)通知 已注册的通道。然后通道将需要处理的信息，通过缓冲（Buffer）打包，编码/解码,完成输入输出控制。

通道介绍：
这里主要 介绍ServerSocketChannel和 SocketChannel.它们都是可选择的(selectable)通道，分别可以工作在同步和异步两种方式下（注意，这里的可选择不是指可以选择两 种工作方式，而是指可以有选择的注册自己感兴趣的事件）。可以用channel.configureBlocking(Boolean )来设置其工作方式。与以前版本的API相比较，ServerSocketChannel就相当于ServerSocket (ServerSocketChannel封装了ServerSocket),而SocketChannel就相当于Socket （SocketChannel封装了Socket）。当通道工作在同步方式时，编程方法与以前的基本相似，这里主要介绍异步工作方式。

所 谓异步输入输出机制，是指在进行输入输出处理时，不必等到输入输出处理完毕才返回。所以异步的同义语是非阻塞（None Blocking）。在服务器端，ServerSocketChannel通过静态函数open()返回一个实例serverChl。然后该通道调用 serverChl.socket().bind()绑定到服务器某端口，并调用register（Selector sel, SelectionKey.OP_ACCEPT）注册OP_ACCEPT事件到一个选择器中（ServerSocketChannel只可以注册 OP_ACCEPT事件）。当有客户请求连接时，选择器就会通知该通道有客户连接请求，就可以进行相应的输入输出控制了；在客户端，clientChl实 例注册自己感兴趣的事件后（可以是OP_CONNECT,OP_READ,OP_WRITE的组合），调用clientChl.connect (InetSocketAddress )连接服务器然后进行相应处理。注意，这里的连接是异步的，即会立即返回而继续执行后面的代码。

选择器和选择键介绍：
选 择器（Selector）的作用是：将通道感兴趣的事件放入队列中，而不是马上提交给应用程序，等已注册的通道自己来请求处理这些事件。换句话说，就是选 择器将会随时报告已经准备好了的通道，而且是按照先进先出的顺序。那么，选择器是通过什么来报告的呢？选择键(SelectionKey)。选择键的作用 就是表明哪个通道已经做好了准备，准备干什么。你也许马上会想到，那一定是已注册的通道感兴趣的事件。不错，例如对于服务器端serverChl来说，可 以调用key.isAcceptable()来通知serverChl有客户端连接请求。相应的函数还有： SelectionKey.isReadable(),SelectionKey.isWritable()。一般的，在一个循环中轮询感兴趣的事件（具 体可参照下面的代码）。如果选择器中尚无通道已注册事件发生，调用Selector.select()将阻塞，直到有事件发生为止。另外，可以调用 selectNow()或者select(long timeout)。前者立即返回，没有事件时返回0值；后者等待timeout时间后返回。一个选择器最多可以同时被63个通道一起注册使用。

应用实例：
下面是用异步输入输出机制实现的客户/服务器实例程序――程序清单1（限于篇幅，只给出了服务器端实现，读者可以参照着实现客户端代码）：

程序类图

public class NBlockingServer {
   int port = 8000;
   int BUFFERSIZE = 1024;
   Selector selector = null;
   ServerSocketChannel serverChannel = null;
   HashMap clientChannelMap = null;//用来存放每一个客户连接对应的套接字和通道
   
   public NBlockingServer( int port ) {
       this.clientChannelMap = new HashMap();
       this.port = port;
   }
   
   public void initialize() throws IOException {
     //初始化，分别实例化一个选择器，一个服务器端可选择通道
     this.selector = Selector.open();
     this.serverChannel = ServerSocketChannel.open();
     this.serverChannel.configureBlocking(false);
     InetAddress localhost = InetAddress.getLocalHost();
     InetSocketAddress isa = new InetSocketAddress(localhost, this.port );
     this.serverChannel.socket().bind(isa);//将该套接字绑定到服务器某一可用端口
   }
   //结束时释放资源
   public void finalize() throws IOException {
       this.serverChannel.close();
       this.selector.close();
   }
   //将读入字节缓冲的信息解码
   public String decode( ByteBuffer byteBuffer ) throws
CharacterCodingException {
       Charset charset = Charset.forName( "ISO-8859-1" );
       CharsetDecoder decoder = charset.newDecoder();
       CharBuffer charBuffer = decoder.decode( byteBuffer );
       String result = charBuffer.toString();
       return result;
   }
   //监听端口，当通道准备好时进行相应操作
   public void portListening() throws IOException, InterruptedException {
     //服务器端通道注册OP_ACCEPT事件
     SelectionKey acceptKey =this.serverChannel.register( this.selector,
                                          SelectionKey.OP_ACCEPT );
       //当有已注册的事件发生时,select()返回值将大于0
       while (acceptKey.selector().select() > 0 ) {
           System.out.println("event happened");
           //取得所有已经准备好的所有选择键
           Set readyKeys = this.selector.selectedKeys();
           //使用迭代器对选择键进行轮询
           Iterator i = readyKeys.iterator();
           while (i.hasNext()) {
               SelectionKey key = (SelectionKey)i.next();
               i.remove();//删除当前将要处理的选择键
               if ( key.isAcceptable() ) {//如果是有客户端连接请求
                   System.out.println("more client connect in!");
                   ServerSocketChannel nextReady =
                       (ServerSocketChannel)key.channel();
                   //获取客户端套接字
                   Socket s = nextReady.accept();
                   //设置对应的通道为异步方式并注册感兴趣事件
                   s.getChannel().configureBlocking( false );
                   SelectionKey readWriteKey =
                       s.getChannel().register( this.selector,
                           SelectionKey.OP_READ|SelectionKey.OP_WRITE  );
                   //将注册的事件与该套接字联系起来
readWriteKey.attach( s );
//将当前建立连接的客户端套接字及对应的通道存放在哈希表//clientChannelMap中
                   this.clientChannelMap.put( s, new
ClientChInstance( s.getChannel() ) );
                   }
               else if ( key.isReadable() ) {//如果是通道读准备好事件
                   System.out.println("Readable");
                   //取得选择键对应的通道和套接字
                   SelectableChannel nextReady =
                       (SelectableChannel) key.channel();
                   Socket socket = (Socket) key.attachment();
                   //处理该事件，处理方法已封装在类ClientChInstance中
                   this.readFromChannel( socket.getChannel(),
                   (ClientChInstance)
this.clientChannelMap.get( socket ) );
               }
               else if ( key.isWritable() ) {//如果是通道写准备好事件
                   System.out.println("writeable");
                   //取得套接字后处理，方法同上
                   Socket socket = (Socket) key.attachment();
                   SocketChannel channel = (SocketChannel)
socket.getChannel();
                   this.writeToChannel( channel,"This is from server!");
               }
           }
       }
   }

 //对通道的写操作
   public void writeToChannel( SocketChannel channel, String message )
throws IOException {
       ByteBuffer buf = ByteBuffer.wrap( message.getBytes()  );
       int nbytes = channel.write( buf );
   }
    //对通道的读操作
   public void readFromChannel( SocketChannel channel, ClientChInstance clientInstance )
   throws IOException, InterruptedException {
       ByteBuffer byteBuffer = ByteBuffer.allocate( BUFFERSIZE );
       int nbytes = channel.read( byteBuffer );
       byteBuffer.flip();
       String result = this.decode( byteBuffer );
       //当客户端发出”@exit”退出命令时，关闭其通道
       if ( result.indexOf( "@exit" ) >= 0 ) {
           channel.close();
       }
       else {
               clientInstance.append( result.toString() );
               //读入一行完毕，执行相应操作
               if ( result.indexOf( "/n" ) >= 0 ){
               System.out.println("client input"+result);
               clientInstance.execute();
               }
       }
   }
   //该类封装了怎样对客户端的通道进行操作，具体实现可以通过重载execute()方法
   public class ClientChInstance {
       SocketChannel channel;
       StringBuffer buffer=new StringBuffer();
       public ClientChInstance( SocketChannel channel ) {
           this.channel = channel;
       }
       public void execute() throws IOException {
           String message = "This is response after reading from channel!";
           writeToChannel( this.channel, message );
           buffer = new StringBuffer();
       }
       //当一行没有结束时，将当前字窜置于缓冲尾
       public void append( String values ) {
           buffer.append( values );
       }
   }


   //主程序
   public static void main( String[] args ) {
       NBlockingServer nbServer = new NBlockingServer(8000);
       try {
           nbServer.initialize();
       } catch ( Exception e ) {
           e.printStackTrace();
           System.exit( -1 );
       }
       try {
           nbServer.portListening();
       }
       catch ( Exception e ) {
           e.printStackTrace();
       }
   }
}

程序清单1

小结：
从 以上程序段可以看出，服务器端没有引入多余线程就完成了多客户的客户/服务器模式。该程序中使用了回调模式(CALLBACK)，细心的读者应该早就看出 来了。需要注意的是，请不要将原来的输入输出包与新加入的输入输出包混用，因为出于一些原因的考虑，这两个包并不兼容。即使用通道时请使用缓冲完成输入输 出控制。该程序在Windows2000,J2SE1.4下，用telnet测试成功。

参考文献：

《JavaTM 2 Platform, Standard Edition, v 1.4.0 API Specification》

关于作者
杨健，中南工业大学计算机科学与技术专业硕士研究生，参与过大型MIS系统开发，网站建设等，现在正致力于Java技术的研究。Email:ytjcopy@china.com