細說Reactor模式

      今天在看書的時候看到了一個新的設計模式——Reactor模式，這個模式是出現在NIO中，至於這到底是個什麼模式，今天我們來細說一下。

一、是什麼

1、概念

      reactor設計模式，是一種基於事件驅動的設計模式。Reactor框架是ACE各個框架中最基礎的一個框架，其他框架都或多或少地用到了Reactor框架。
      在事件驅動的應用中，將一個或多個客戶的服務請求分離（demultiplex）和調度（dispatch）給應用程序。在事件驅動的應用中，同步地、有序地處理同時接收的多個服務請求。
      reactor模式與外觀模式有點像。不過，觀察者模式與單個事件源關聯，而反應器模式則與多個事件源關聯 。當一個主體發生改變時，所有依屬體都得到通知。

2、優點

       1）響應快，不必爲單個同步時間所阻塞，雖然Reactor本身依然是同步的；
       2）編程相對簡單，可以最大程度的避免複雜的多線程及同步問題，並且避免了多線程/進程的切換開銷；
       3）可擴展性，可以方便的通過增加Reactor實例個數來充分利用CPU資源；
       4）可複用性，reactor框架本身與具體事件處理邏輯無關，具有很高的複用性；

3、缺點

      1）相比傳統的簡單模型，Reactor增加了一定的複雜性，因而有一定的門檻，並且不易於調試。
      2）Reactor模式需要底層的Synchronous Event Demultiplexer支持，比如Java中的Selector支持，操作系統的select系統調用支持，如果要自己實現Synchronous Event Demultiplexer可能不會有那麼高效。
      3） Reactor模式在IO讀寫數據時還是在同一個線程中實現的，即使使用多個Reactor機制的情況下，那些共享一個Reactor的Channel如果出現一個長時間的數據讀寫，會影響這個Reactor中其他Channel的相應時間，比如在大文件傳輸時，IO操作就會影響其他Client的相應時間，因而對這種操作，使用傳統的Thread-Per-Connection或許是一個更好的選擇，或則此時使用Proactor模式。

二、架構模式

1、架構圖

2、構成

Handles ：表示操作系統管理的資源，我們可以理解爲fd。

Synchronous Event Demultiplexer ：同步事件分離器，阻塞等待Handles中的事件發生。

Initiation Dispatcher ：初始分派器，作用爲添加Event handler（事件處理器）、刪除Event handler以及分派事件給Event handler。也就是說，Synchronous Event Demultiplexer負責等待新事件發生，事件發生時通知Initiation Dispatcher，然後Initiation Dispatcher調用event handler處理事件。

Event Handler ：事件處理器的接口

Concrete Event Handler ：事件處理器的實際實現，而且綁定了一個Handle。因爲在實際情況中，我們往往不止一種事件處理器，因此這裏將事件處理器接口和實現分開，與C++、Java這些高級語言中的多態類似。

3、模塊交互

      1）我們註冊Concrete Event Handler到Initiation Dispatcher中。
      2）Initiation Dispatcher調用每個Event Handler的get_handle接口獲取其綁定的Handle。
      3）Initiation Dispatcher調用handle_events開始事件處理循環。在這裏，Initiation Dispatcher會將步驟2獲取的所有Handle都收集起來，使用Synchronous Event Demultiplexer來等待這些Handle的事件發生。
     4）當某個（或某幾個）Handle的事件發生時，Synchronous Event Demultiplexer通知Initiation Dispatcher。
       5）Initiation Dispatcher根據發生事件的Handle找出所對應的Handler。
       6）Initiation Dispatcher調用Handler的handle_event方法處理事件。

三、代碼註釋

package com.linxcool.reactor;  

import java.io.IOException;  
import java.net.InetAddress;  
import java.net.InetSocketAddress;  
import java.nio.channels.SelectionKey;  
import java.nio.channels.Selector;  
import java.nio.channels.ServerSocketChannel;  
import java.util.Iterator;  
import java.util.Set;  

/** 
 * 反應器模式 
 * 用於解決多用戶訪問併發問題 
 *  
 * 舉個例子：餐廳服務問題 
 *  
 * 傳統線程池做法：來一個客人(請求)去一個服務員(線程) 
 * 反應器模式做法：當客人點菜的時候，服務員就可以去招呼其他客人了，等客人點好了菜，直接招呼一聲“服務員” 
 *  
 * @author linxcool 
 */  
public class Reactor implements Runnable{  
    public final Selector selector;  
    public final ServerSocketChannel serverSocketChannel;  

    public Reactor(int port) throws IOException{  
        selector=Selector.open();  
        serverSocketChannel=ServerSocketChannel.open();  
        InetSocketAddress inetSocketAddress=new InetSocketAddress(InetAddress.getLocalHost(),port);  
        serverSocketChannel.socket().bind(inetSocketAddress);  
        serverSocketChannel.configureBlocking(false);  

        //向selector註冊該channel    
        SelectionKey selectionKey=serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);  

        //利用selectionKey的attache功能綁定Acceptor 如果有事情，觸發Acceptor   
        selectionKey.attach(new Acceptor(this));  
    }  

    @Override  
    public void run() {  
        try {  
            while(!Thread.interrupted()){  
                selector.select();  
                Set<SelectionKey> selectionKeys= selector.selectedKeys();  
                Iterator<SelectionKey> it=selectionKeys.iterator();  
                //Selector如果發現channel有OP_ACCEPT或READ事件發生，下列遍歷就會進行。  
                while(it.hasNext()){  
                    //來一個事件 第一次觸發一個accepter線程    
                    //以後觸發SocketReadHandler  
                    SelectionKey selectionKey=it.next();  
                    dispatch(selectionKey);  
                    selectionKeys.clear();  
                }  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  

    /** 
     * 運行Acceptor或SocketReadHandler 
     * @param key 
     */  
    void dispatch(SelectionKey key) {  
        Runnable r = (Runnable)(key.attachment());    
        if (r != null){    
            r.run();  
        }    
    }    

}  

package com.linxcool.reactor;  

import java.io.IOException;  
import java.nio.channels.SocketChannel;  

public class Acceptor implements Runnable{  
    private Reactor reactor;  
    public Acceptor(Reactor reactor){  
        this.reactor=reactor;  
    }  
    @Override  
    public void run() {  
        try {  
            SocketChannel socketChannel=reactor.serverSocketChannel.accept();  
            if(socketChannel!=null)//調用Handler來處理channel  
                new SocketReadHandler(reactor.selector, socketChannel);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  

package com.linxcool.reactor;  

import java.io.IOException;  
import java.nio.ByteBuffer;  
import java.nio.channels.SelectionKey;  
import java.nio.channels.Selector;  
import java.nio.channels.SocketChannel;  

public class SocketReadHandler implements Runnable{  
    private SocketChannel socketChannel;  
    public SocketReadHandler(Selector selector,SocketChannel socketChannel) throws IOException{  
        this.socketChannel=socketChannel;  
        socketChannel.configureBlocking(false);  

        SelectionKey selectionKey=socketChannel.register(selector, 0);  

        //將SelectionKey綁定爲本Handler 下一步有事件觸發時，將調用本類的run方法。    
        //參看dispatch(SelectionKey key)    
        selectionKey.attach(this);  

        //同時將SelectionKey標記爲可讀，以便讀取。    
        selectionKey.interestOps(SelectionKey.OP_READ);    
        selector.wakeup();  
    }  

    /** 
     * 處理讀取數據 
     */  
    @Override  
    public void run() {  
        ByteBuffer inputBuffer=ByteBuffer.allocate(1024);  
        inputBuffer.clear();  
        try {  
            socketChannel.read(inputBuffer);  
            //激活線程池 處理這些request  
            //requestHandle(new Request(socket,btt));   
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  

總結：

      reactor模式是javaNIO非堵塞技術的實現原理，我們不僅要知道其原理流程，還要知道其代碼實現，當然這個reactor模式不僅僅在NIO中實現，而且在redies等其他地方也出現過，說明這個模式還是比較實用的，尤其是在多線程高併發的情況下使用。