【Java TCP/IP Socket】基于NIO的TCP通信(含代码)

来源:互联网 发布:网络无抵押贷款平台 编辑:程序博客网 时间:2024/03/29 17:37

 NIO主要原理及使用

    NIO采取通道(Channel)和缓冲区(Buffer)来传输和保存数据,它是非阻塞式的I/O,即在等待连接、读写数据(这些都是在一线程以客户端的程序中会阻塞线程的操作)的时候,程序也可以做其他事情,以实现线程的异步操作。

   考虑一个即时消息服务器,可能有上千个客户端同时连接到服务器,但是在任何时刻只有非常少量的消息需要读取和分发(如果采用线程池或者一线程一客户端方式,则会非常浪费资源),这就需要一种方法能阻塞等待,直到有一个信道可以进行I/O操作。NIO的Selector选择器就实现了这样的功能,一个Selector实例可以同时检查一组信道的I/O状态,它就类似一个观察者,只要我们把需要探知的SocketChannel告诉Selector,我们接着做别的事情,当有事件(比如,连接打开、数据到达等)发生时,它会通知我们,传回一组SelectionKey,我们读取这些Key,就会获得我们刚刚注册过的SocketChannel,然后,我们从这个Channel中读取数据,接着我们可以处理这些数据。

    Selector内部原理实际是在做一个对所注册的Channel的轮询访问,不断的轮询(目前就这一个算法),一旦轮询到一个Channel有所注册的事情发生,比如数据来了,它就会读取Channel中的数据,并对其进行处理。

    要使用选择器,需要创建一个Selector实例,并将其注册到想要监控的信道上(通过Channel的方法实现)。最后调用选择器的select()方法,该方法会阻塞等待,直到有一个或多个信道准备好了I/O操作或等待超时,或另一个线程调用了该选择器的wakeup()方法。现在,在一个单独的线程中,通过调用select()方法,就能检查多个信道是否准备好进行I/O操作,由于非阻塞I/O的异步特性,在检查的同时,我们也可以执行其他任务。


   基于NIO的TCP连接的建立步骤


  服务端

    1、传建一个Selector实例;

    2、将其注册到各种信道,并指定每个信道上感兴趣的I/O操作;

    3、重复执行:

        1)调用一种select()方法;

        2)获取选取的键列表;

        3)对于已选键集中的每个键:

           a、获取信道,并从键中获取附件(如果为信道及其相关的key添加了附件的话);

           b、确定准备就绪的操纵并执行,如果是accept操作,将接收的信道设置为非阻塞模式,并注册到选择器;

           c、如果需要,修改键的兴趣操作集;

           d、从已选键集中移除键


     客户端

   与基于多线程的TCP客户端大致相同,只是这里是通过信道建立的连接,但在等待连接建立及读写时,我们可以异步地执行其他任务。


   基于NIO的TCP通信Demo

    下面给出一个基于NIO的TCP通信的Demo,客户端发送一串字符串到服务端,服务端将该字符串原原本本地反馈给客户端。

    客户端代码及其详细注释如下:

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. import java.net.InetSocketAddress;  
  2. import java.net.SocketException;  
  3. import java.nio.ByteBuffer;  
  4. import java.nio.channels.SocketChannel;  
  5.   
  6. public class TCPEchoClientNonblocking {  
  7.     public static void main(String args[]) throws Exception{  
  8.         if ((args.length < 2) || (args.length > 3))   
  9.         throw new IllegalArgumentException("参数不正确");  
  10.         //第一个参数作为要连接的服务端的主机名或IP  
  11.         String server = args[0];   
  12.         //第二个参数为要发送到服务端的字符串  
  13.         byte[] argument = args[1].getBytes();  
  14.         //如果有第三个参数,则作为端口号,如果没有,则端口号设为7  
  15.         int servPort = (args.length == 3) ? Integer.parseInt(args[2]) : 7;  
  16.         //创建一个信道,并设为非阻塞模式  
  17.         SocketChannel clntChan = SocketChannel.open();  
  18.         clntChan.configureBlocking(false);  
  19.         //向服务端发起连接  
  20.         if (!clntChan.connect(new InetSocketAddress(server, servPort))){  
  21.             //不断地轮询连接状态,直到完成连接  
  22.             while (!clntChan.finishConnect()){  
  23.                 //在等待连接的时间里,可以执行其他任务,以充分发挥非阻塞IO的异步特性  
  24.                 //这里为了演示该方法的使用,只是一直打印"."  
  25.                 System.out.print(".");    
  26.             }  
  27.         }  
  28.         //为了与后面打印的"."区别开来,这里输出换行符  
  29.         System.out.print("\n");  
  30.         //分别实例化用来读写的缓冲区  
  31.         ByteBuffer writeBuf = ByteBuffer.wrap(argument);  
  32.         ByteBuffer readBuf = ByteBuffer.allocate(argument.length);  
  33.         //接收到的总的字节数  
  34.         int totalBytesRcvd = 0;   
  35.         //每一次调用read()方法接收到的字节数  
  36.         int bytesRcvd;   
  37.         //循环执行,直到接收到的字节数与发送的字符串的字节数相等  
  38.         while (totalBytesRcvd < argument.length){  
  39.             //如果用来向通道中写数据的缓冲区中还有剩余的字节,则继续将数据写入信道  
  40.             if (writeBuf.hasRemaining()){  
  41.                 clntChan.write(writeBuf);  
  42.             }  
  43.             //如果read()接收到-1,表明服务端关闭,抛出异常  
  44.             if ((bytesRcvd = clntChan.read(readBuf)) == -1){  
  45.                 throw new SocketException("Connection closed prematurely");  
  46.             }  
  47.             //计算接收到的总字节数  
  48.             totalBytesRcvd += bytesRcvd;  
  49.             //在等待通信完成的过程中,程序可以执行其他任务,以体现非阻塞IO的异步特性  
  50.             //这里为了演示该方法的使用,同样只是一直打印"."  
  51.             System.out.print(".");   
  52.         }  
  53.         //打印出接收到的数据  
  54.         System.out.println("Received: " +  new String(readBuf.array(), 0, totalBytesRcvd));  
  55.         //关闭信道  
  56.         clntChan.close();  
  57.     }  
  58. }  


    服务端用单个线程监控一组信道,代码如下:

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. import java.io.IOException;  
  2. import java.net.InetSocketAddress;  
  3. import java.nio.channels.SelectionKey;  
  4. import java.nio.channels.Selector;  
  5. import java.nio.channels.ServerSocketChannel;  
  6. import java.util.Iterator;  
  7.   
  8. public class TCPServerSelector{  
  9.     //缓冲区的长度  
  10.     private static final int BUFSIZE = 256;   
  11.     //select方法等待信道准备好的最长时间  
  12.     private static final int TIMEOUT = 3000;   
  13.     public static void main(String[] args) throws IOException {  
  14.         if (args.length < 1){  
  15.             throw new IllegalArgumentException("Parameter(s): <Port> ...");  
  16.         }  
  17.         //创建一个选择器  
  18.         Selector selector = Selector.open();  
  19.         for (String arg : args){  
  20.             //实例化一个信道  
  21.             ServerSocketChannel listnChannel = ServerSocketChannel.open();  
  22.             //将该信道绑定到指定端口  
  23.             listnChannel.socket().bind(new InetSocketAddress(Integer.parseInt(arg)));  
  24.             //配置信道为非阻塞模式  
  25.             listnChannel.configureBlocking(false);  
  26.             //将选择器注册到各个信道  
  27.             listnChannel.register(selector, SelectionKey.OP_ACCEPT);  
  28.         }  
  29.         //创建一个实现了协议接口的对象  
  30.         TCPProtocol protocol = new EchoSelectorProtocol(BUFSIZE);  
  31.         //不断轮询select方法,获取准备好的信道所关联的Key集  
  32.         while (true){  
  33.             //一直等待,直至有信道准备好了I/O操作  
  34.             if (selector.select(TIMEOUT) == 0){  
  35.                 //在等待信道准备的同时,也可以异步地执行其他任务,  
  36.                 //这里只是简单地打印"."  
  37.                 System.out.print(".");  
  38.                 continue;  
  39.             }  
  40.             //获取准备好的信道所关联的Key集合的iterator实例  
  41.             Iterator<SelectionKey> keyIter = selector.selectedKeys().iterator();  
  42.             //循环取得集合中的每个键值  
  43.             while (keyIter.hasNext()){  
  44.                 SelectionKey key = keyIter.next();   
  45.                 //如果服务端信道感兴趣的I/O操作为accept  
  46.                 if (key.isAcceptable()){  
  47.                     protocol.handleAccept(key);  
  48.                 }  
  49.                 //如果客户端信道感兴趣的I/O操作为read  
  50.                 if (key.isReadable()){  
  51.                     protocol.handleRead(key);  
  52.                 }  
  53.                 //如果该键值有效,并且其对应的客户端信道感兴趣的I/O操作为write  
  54.                 if (key.isValid() && key.isWritable()) {  
  55.                     protocol.handleWrite(key);  
  56.                 }  
  57.                 //这里需要手动从键集中移除当前的key  
  58.                 keyIter.remove();   
  59.             }  
  60.         }  
  61.     }  
  62. }  

    这里为了使不同协议都能方便地使用这个基本的服务模式,我们把信道中与具体协议相关的处理各种I/O的操作分离了出来,定义了一个接口,如下:

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. import java.nio.channels.SelectionKey;  
  2. import java.io.IOException;  
  3.   
  4. /** 
  5. *该接口定义了通用TCPSelectorServer类与特定协议之间的接口, 
  6. *它把与具体协议相关的处理各种I/O的操作分离了出来, 
  7. *以使不同协议都能方便地使用这个基本的服务模式。 
  8. */  
  9. public interface TCPProtocol{  
  10.     //accept I/O形式  
  11.     void handleAccept(SelectionKey key) throws IOException;  
  12.     //read I/O形式  
  13.     void handleRead(SelectionKey key) throws IOException;  
  14.     //write I/O形式  
  15.     void handleWrite(SelectionKey key) throws IOException;  
  16. }  


    接口的实现类代码如下:

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. import java.nio.channels.SelectionKey;  
  2. import java.nio.channels.SocketChannel;  
  3. import java.nio.channels.ServerSocketChannel;  
  4. import java.nio.ByteBuffer;  
  5. import java.io.IOException;  
  6.   
  7. public class EchoSelectorProtocol implements TCPProtocol {  
  8.     private int bufSize; // 缓冲区的长度  
  9.     public EchoSelectorProtocol(int bufSize){  
  10.     this.bufSize = bufSize;  
  11.     }  
  12.   
  13.     //服务端信道已经准备好了接收新的客户端连接  
  14.     public void handleAccept(SelectionKey key) throws IOException {  
  15.         SocketChannel clntChan = ((ServerSocketChannel) key.channel()).accept();  
  16.         clntChan.configureBlocking(false);  
  17.         //将选择器注册到连接到的客户端信道,并指定该信道key值的属性为OP_READ,同时为该信道指定关联的附件  
  18.         clntChan.register(key.selector(), SelectionKey.OP_READ, ByteBuffer.allocate(bufSize));  
  19.     }  
  20.   
  21.     //客户端信道已经准备好了从信道中读取数据到缓冲区  
  22.     public void handleRead(SelectionKey key) throws IOException{  
  23.         SocketChannel clntChan = (SocketChannel) key.channel();  
  24.         //获取该信道所关联的附件,这里为缓冲区  
  25.         ByteBuffer buf = (ByteBuffer) key.attachment();  
  26.         long bytesRead = clntChan.read(buf);  
  27.         //如果read()方法返回-1,说明客户端关闭了连接,那么客户端已经接收到了与自己发送字节数相等的数据,可以安全地关闭  
  28.         if (bytesRead == -1){   
  29.             clntChan.close();  
  30.         }else if(bytesRead > 0){  
  31.         //如果缓冲区总读入了数据,则将该信道感兴趣的操作设置为为可读可写  
  32.         key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);  
  33.         }  
  34.     }  
  35.       
  36.     //客户端信道已经准备好了将数据从缓冲区写入信道  
  37.     public void handleWrite(SelectionKey key) throws IOException {  
  38.     //获取与该信道关联的缓冲区,里面有之前读取到的数据  
  39.     ByteBuffer buf = (ByteBuffer) key.attachment();  
  40.     //重置缓冲区,准备将数据写入信道  
  41.     buf.flip();   
  42.     SocketChannel clntChan = (SocketChannel) key.channel();  
  43.     //将数据写入到信道中  
  44.     clntChan.write(buf);  
  45.     if (!buf.hasRemaining()){   
  46.     //如果缓冲区中的数据已经全部写入了信道,则将该信道感兴趣的操作设置为可读  
  47.       key.interestOps(SelectionKey.OP_READ);  
  48.     }  
  49.     //为读入更多的数据腾出空间  
  50.     buf.compact();   
  51.   }  
  52.   
  53. }  

    执行结果如下:

      
   说明:以上的服务端程序,select()方法第一次能选择出来的准备好的信道都是服务端信道,其关联键值的属性都为OP_ACCEPT,亦及有效操作都为accept,在执行handleAccept方法时,为取得连接的客户端信道也进行了注册,属性为OP_READ,这样下次轮询调用select()方法时,便会检查到对read操作感兴趣的客户端信道(当然也有可能有关联accept操作兴趣集的信道),从而调用handleRead方法,在该方法中又注册了OP_WRITE属性,那么第三次调用select()方法时,便会检测到对write操作感兴趣的客户端信道(当然也有可能有关联read操作兴趣集的信道),从而调用handleWrite方法。
    
   结果:从结果中很明显地可以看出,服务器端在等待信道准备好的时候,线程没有阻塞,而是可以执行其他任务,这里只是简单的打印".",客户端在等待连接和等待数据读写完成的时候,线程没有阻塞,也可以执行其他任务,这里也正是简单的打印"."。

   几个需要注意的地方

    1、对于非阻塞SocketChannel来说,一旦已经调用connect()方法发起连接,底层套接字可能既不是已经连接,也不是没有连接,而是正在连接。由于底层协议的工作机制,套接字可能会在这个状态一直保持下去,这时候就需要循环地调用finishConnect()方法来检查是否完成连接,在等待连接的同时,线程也可以做其他事情,这便实现了线程的异步操作。

    2、write()方法的非阻塞调用哦只会写出其能够发送的数据,而不会阻塞等待所有数据,而后一起发送,因此在调用write()方法将数据写入信道时,一般要用到while循环,如:
while(buf.hasRemaining())
    channel.write(buf);

    3、任何对key(信道)所关联的兴趣操作集的改变,都只在下次调用了select()方法后才会生效。

    4、selectedKeys()方法返回的键集是可修改的,实际上在两次调用select()方法之间,都必须手动将其清空,否则,它就会在下次调用select()方法时仍然保留在集合中,而且可能会有无用的操作来调用它,换句话说,select()方法只会在已有的所选键集上添加键,它们不会创建新的建集。

    5、对于ServerSocketChannel来说,accept是唯一的有效操作,而对于SocketChannel来说,有效操作包括读、写和连接,另外,对于DatagramChannle,只有读写操作是有效的。
0 0
原创粉丝点击