使用非阻塞ServerSocketChannel、SocketChannel代替ServerSocket和Socket

在使用传统的ServerSocket和Socket的时候很多时候程序是会阻塞的

比如 serversocket.accept() , socket.getInputStream().read() 的时候都会阻塞 accept()方法除非等到客户端socket的连接或者被异常中断否则会一直等待下去

read()方法也是如此除非在输入流中有了足够的数据否则该方法也会一直等待下去知道数据的到来.在ServerSocket与Socket的方式中服务器端往往要为每一个客户端(socket)分配一个线程,而每一个线程都有可能处于长时间的阻塞状态中.而过多的线程也会影响服务器的性能.在JDK1.4引入了非阻塞的通信方式,这样使得服务器端只需要一个线程就能处理所有客户端socket的请求.

下面是几个需要用到的核心类

ServerSocketChannel: ServerSocket 的替代类, 支持阻塞通信与非阻塞通信.
SocketChannel: Socket 的替代类, 支持阻塞通信与非阻塞通信.
Selector: 为ServerSocketChannel 监控接收客户端连接就绪事件, 为 SocketChannel 监控连接服务器就绪, 读就绪和写就绪事件.
SelectionKey: 代表 ServerSocketChannel 及 SocketChannel 向 Selector 注册事件的句柄. 当一个 SelectionKey 对象位于Selector 对象的 selected-keys 集合中时, 就表示与这个 SelectionKey 对象相关的事件发生了.在SelectionKey 类中有几个静态常量
SelectionKey.OP_ACCEPT ->客户端连接就绪事件等于监听serversocket.accept()返回一个socket
SelectionKey.OP_CONNECT ->准备连接服务器就绪跟上面类似,只不过是对于socket的相当于监听了 socket.connect()
SelectionKey.OP_READ ->读就绪事件, 表示输入流中已经有了可读数据, 可以执行读操作了
SelectionKey.OP_WRITE          ->写就绪事件
下面是服务器端:

Selector selector = Selector.open();         //静态方法实例化selector
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false); //设置为非阻塞方式,如果为true 那么就为传统的阻塞方式
serverChannel.socket().bind(new InetSocketAddress(port));  //绑定IP 及端口
serverChannel.register(selector, SelectionKey.OP_ACCEPT); //注册 OP_ACCEPT事件

new ServerThread().start(); //开启一个线程处理所有请求

ServerThread中的run方法
[java] view plain copy print ?
1. public void run()
2. {
3. while(true)
4. {
5. try
6. {
7. selector.select();
8. Set<SelectionKey> keys = selector.selectedKeys();
9. Iterator<SelectionKey> iter = keys.iterator();
10. SocketChannel sc ;
11. while(iter.hasNext())
12. {
13. SelectionKey key = iter.next();
14. if(key.isAcceptable()); // 新的连接
15. else if(key.isReadable()) ;// 可读
16. iter.remove(); //处理完事件的要从keys中删去
17. }
18. catch (Exception e)
19. {
20. e.printStackTrace();
21. }
22. }
23. }
```
public void run()
  {
   while(true)
   {
    try
    {
     selector.select();
     Set<SelectionKey> keys = selector.selectedKeys();
     Iterator<SelectionKey> iter = keys.iterator();
     SocketChannel sc ;
     while(iter.hasNext())
     {
      SelectionKey key = iter.next();
      if(key.isAcceptable());  // 新的连接
       else if(key.isReadable()) ;// 可读     
       iter.remove(); //处理完事件的要从keys中删去      
     }
    catch (Exception e)
    {
     e.printStackTrace();
    }
   }
  }
```
其中在 isAcceptable()中通过        ServerSocketChannel ssc = (ServerSocketChannel) key.channel(); SocketChannel sc = ssc.accept(); 得到客户端的SocketChannel

在isReadable()中SocketChannel sc = (SocketChannel) key.channel(); 得到SocketChannel .

在SocketChannel 对象中可以用write() read() 进行读写操作只不过操作的对象不再是byte[] String之类而是ByteBuffer

客户端基本一样

  selector = Selector.open();
  channel = SocketChannel.open(new InetSocketAddress(port));
  channel.configureBlocking(false);
  channel.register(selector,SelectionKey.OP_CONNECT);
  new ClientThread().start();

run方法

    while (true)
    {
     selector.select();
     Set<SelectionKey> keys = selector.selectedKeys();
     Iterator<SelectionKey> iter = keys.iterator();
     while(iter.hasNext())
     {
      SelectionKey key = iter.next();

      if(key.isConnectable());//连接成功&正常

      else if(key.isReadable())//可读

      iter.remove();

    }

可以通过key.channel();方法得到当前的socketchannel对象

总结其实这里将阻塞变为非阻塞实际是用一个while死循环来处理的

首先通过seleector.select()重新得到事件只要有事件无论是什么都交给循环体去处理在循环体中分别进行不同的处理

而多个socket通过一个seleector进行同意管理

while(一直等待, 直到有接收连接就绪事件, 读就绪事件或写就绪事件发生){             //阻塞

              if(有客户连接)

                   接收客户的连接;                                                    //非阻塞

              if(某个 Socket 的输入流中有可读数据)

                   从输入流中读数据;                                                 //非阻塞

              if(某个 Socket 的输出流可以写数据)

                   向输出流写数据;                                                    //非阻塞

       }

类似这样  以上处理流程采用了轮询的工作方式, 当某一种操作就绪时, 就执行该操作, 否则就查看是否还有其他就绪的操作可以执行. 线程不会因为某一个操作还没有就绪, 就进入阻塞状态, 一直傻傻地在那里等待这个操作就绪.

使用非阻塞ServerSocketChannel、SocketChannel代替ServerSocket和Socket

猜你喜欢