Reactor模式和NIO

板橋里人 jdon.com 2002/11/08

當前分散式計算　Web Services盛行天下，這些網路服務的底層都離不開對socket的操作。他們都有一個共同的結構：
1. Read request
2. Decode request
3. Process service
4. Encode reply
5. Send reply

經典的網路服務的設計如下圖，在每個執行緒中完成對資料的處理：

但這種模式在使用者負載增加時，效能將下降非常的快。我們需要重新尋找一個新的方案，保持資料處理的流暢，很顯然，事件觸發機制是最好的解決辦法，當有事件發生時，會觸動handler,然後開始資料的處理。

Reactor模式類似於AWT中的Event處理：

Reactor模式參與者

1.Reactor 負責響應IO事件，一旦發生，廣播發送給相應的Handler去處理,這類似於AWT的thread
2.Handler 是負責非堵塞行為，類似於AWT ActionListeners；同時負責將handlers與event事件繫結，類似於AWT addActionListener

如圖：

Java的NIO為reactor模式提供了實現的基礎機制，它的Selector當發現某個channel有資料時，會通過SlectorKey來告知我們，在此我們實現事件和handler的繫結。

我們來看看Reactor模式程式碼:

public class Reactor implements Runnable{

　　final Selector selector;
　　final ServerSocketChannel serverSocket;

　　Reactor(int port) throws IOException {
　　　　selector = Selector.open();
　　　　serverSocket = ServerSocketChannel.open();
　　　　InetSocketAddress address = new InetSocketAddress(InetAddress.getLocalHost(),port);
　　　　serverSocket.socket().bind(address);

　　　　serverSocket.configureBlocking(false);
　　　　//向selector註冊該channel
　　　　 SelectionKey sk =serverSocket.register(selector,SelectionKey.OP_ACCEPT);

　　　　logger.debug("-->Start serverSocket.register!");

　　　　//利用sk的attache功能繫結Acceptor 如果有事情，觸發Acceptor
　　　　sk.attach(new Acceptor());
　　　　logger.debug("-->attach(new Acceptor()!");
　　}


　　public void run() { // normally in a new Thread
　　　　try {
　　　　while (!Thread.interrupted())
　　　　{
　　　　　　selector.select();
　　　　　　Set selected = selector.selectedKeys();
　　　　　　Iterator it = selected.iterator();
　　　　　　//Selector如果發現channel有OP_ACCEPT或READ事件發生，下列遍歷就會進行。
　　　　　　while (it.hasNext())
　　　　　　　　//來一個事件 第一次觸發一個accepter執行緒
　　　　　　　　//以後觸發SocketReadHandler
　　　　　　　　dispatch((SelectionKey)(it.next()));
　　　　　　　　selected.clear();
　　　　　　}
　　　　}catch (IOException ex) {
　　　　　　　　logger.debug("reactor stop!"+ex);
　　　　}
　　}

　　//執行Acceptor或SocketReadHandler
　　void dispatch(SelectionKey k) {
　　　　Runnable r = (Runnable)(k.attachment());
　　　　if (r != null){
　　　　　　// r.run();

　　　　}
　　}

　　class Acceptor implements Runnable { // inner
　　　　public void run() {
　　　　try {
　　　　　　logger.debug("-->ready for accept!");
　　　　　　SocketChannel c = serverSocket.accept();
　　　　　　if (c != null)
　　　　　　　　//呼叫Handler來處理channel
　　　　　　　　new SocketReadHandler(selector, c);
　　　　　　}
　　　　catch(IOException ex) {
　　　　　　logger.debug("accept stop!"+ex);
　　　　}
　　　　}
　　}
}
 

以上程式碼中巧妙使用了SocketChannel的attach功能，將Hanlder和可能會發生事件的channel連結在一起，當發生事件時，可以立即觸發相應連結的Handler。

再看看Handler程式碼:

public class SocketReadHandler implements Runnable {

　　public static Logger logger = Logger.getLogger(SocketReadHandler.class);

　　private Test test=new Test();

　　final SocketChannel socket;
　　final SelectionKey sk;

　　 static final int READING = 0, SENDING = 1;
　　int state = READING;

　　public SocketReadHandler(Selector sel, SocketChannel c)
　　　　throws IOException {

　　　　socket = c;

　　　　socket.configureBlocking(false);
　　　　 sk = socket.register(sel, 0);

　　　　//將SelectionKey繫結為本Handler 下一步有事件觸發時，將呼叫本類的run方法。
　　　　//參看dispatch(SelectionKey k)
　　　　sk.attach(this);

　　　　//同時將SelectionKey標記為可讀，以便讀取。
　　　　sk.interestOps(SelectionKey.OP_READ);
　　　　sel.wakeup();
　　}

　　public void run() {
　　　　try{
　　　　// test.read(socket,input);
　　　　　　readRequest() ;
　　　　}catch(Exception ex){
　　　　logger.debug("readRequest error"+ex);
　　　　}
　　}


/**
* 處理讀取data
* @param key
* @throws Exception
*/
private void readRequest() throws Exception {

　　ByteBuffer input = ByteBuffer.allocate(1024);
　　input.clear();
　　try{

　　　　int bytesRead = socket.read(input);

　　　　......

　　　　//啟用執行緒池 處理這些request
　　　　requestHandle(new Request(socket,btt));

　　　　.....


　　}catch(Exception e) {
　　}

}

注意在Handler裡面又執行了一次attach，這樣，覆蓋前面的Acceptor，下次該Handler又有READ事件發生時，將直接觸發Handler.從而開始了資料的讀　處理　寫　發出等流程處理。

將資料讀出後，可以將這些資料處理執行緒做成一個執行緒池，這樣，資料讀出後，立即扔到執行緒池中，這樣加速處理速度：

更進一步，我們可以使用多個Selector分別處理連線和讀事件。

一個高效能的Java網路服務機制就要形成，激動人心的叢集平行計算即將實現。