《Scalable IO in Java》筆記

標籤：

Scalable IO in Java

http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf

基本上所有的網路處理常式都有以下基本的處理過程:
Read request
Decode request
Process service
Encode reply
Send reply

Classic Service Designs

簡單的代碼實現：

class Server implements Runnable {    public void run() {        try {            ServerSocket ss = new ServerSocket(PORT);            while (!Thread.interrupted())            new Thread(new Handler(ss.accept())).start(); //建立新線程來handle            // or, single-threaded, or a thread pool        } catch (IOException ex) { /* ... */ }    }        static class Handler implements Runnable {        final Socket socket;        Handler(Socket s) { socket = s; }        public void run() {            try {                byte[] input = new byte[MAX_INPUT];                socket.getInputStream().read(input);                byte[] output = process(input);                socket.getOutputStream().write(output);            } catch (IOException ex) { /* ... */ }        }               private byte[] process(byte[] cmd) { /* ... */ }    }}

對於每一個請求都分發給一個線程，每個線程中都獨自處理上面的流程。

這種模型由於IO在阻塞時會一直等待，因此在使用者負載增加時，效能下降的非常快。

server導致阻塞的原因：

1、serversocket的accept方法，阻塞等待client串連，直到client串連成功。

2、線程從socket inputstream讀入資料，會進入阻塞狀態，直到全部資料讀完。

3、線程向socket outputstream寫入資料，會阻塞直到全部資料寫完。

client導致阻塞的原因：

1、client建立串連時會阻塞，直到串連成功。

2、線程從socket輸入資料流讀入資料，如果沒有足夠資料讀完會進入阻塞狀態，直到有資料或者讀到輸入資料流末尾。

3、線程從socket輸出資料流寫入資料，直到輸出所有資料。

4、socket.setsolinger()設定socket的延遲時間，當socket關閉時，會進入阻塞狀態，直到全部資料都發送完或者逾時。

改進：採用基於事件驅動的設計，當有事件觸發時，才會調用處理器進行資料處理。

Basic Reactor Design

 代碼實現：

class Reactor implements Runnable {     final Selector selector;    final ServerSocketChannel serverSocket;    Reactor(int port) throws IOException { //Reactor初始化        selector = Selector.open();        serverSocket = ServerSocketChannel.open();        serverSocket.socket().bind(new InetSocketAddress(port));        serverSocket.configureBlocking(false); //非阻塞        SelectionKey sk = serverSocket.register(selector, SelectionKey.OP_ACCEPT); //分步處理,第一步,接收accept事件        sk.attach(new Acceptor()); //attach callback object, Acceptor    }        public void run() {         try {            while (!Thread.interrupted()) {                selector.select();                Set selected = selector.selectedKeys();                Iterator it = selected.iterator();                while (it.hasNext())                    dispatch((SelectionKey)(it.next()); //Reactor負責dispatch收到的事件                selected.clear();            }        } catch (IOException ex) { /* ... */ }    }        void dispatch(SelectionKey k) {        Runnable r = (Runnable)(k.attachment()); //調用之前註冊的callback對象        if (r != null)            r.run();    }        class Acceptor implements Runnable { // inner        public void run() {            try {                SocketChannel c = serverSocket.accept();                if (c != null)                new Handler(selector, c);            }            catch(IOException ex) { /* ... */ }        }    }}final class Handler implements Runnable {    final SocketChannel socket;    final SelectionKey sk;    ByteBuffer input = ByteBuffer.allocate(MAXIN);    ByteBuffer output = ByteBuffer.allocate(MAXOUT);    static final int READING = 0, SENDING = 1;    int state = READING;        Handler(Selector sel, SocketChannel c) throws IOException {        socket = c; c.configureBlocking(false);        // Optionally try first read now        sk = socket.register(sel, 0);        sk.attach(this); //將Handler作為callback對象        sk.interestOps(SelectionKey.OP_READ); //第二步,接收Read事件        sel.wakeup();    }    boolean inputIsComplete() { /* ... */ }    boolean outputIsComplete() { /* ... */ }    void process() { /* ... */ }        public void run() {        try {            if (state == READING) read();            else if (state == SENDING) send();        } catch (IOException ex) { /* ... */ }    }        void read() throws IOException {        socket.read(input);        if (inputIsComplete()) {            process();            state = SENDING;            // Normally also do first write now            sk.interestOps(SelectionKey.OP_WRITE); //第三步,接收write事件        }    }    void send() throws IOException {        socket.write(output);        if (outputIsComplete()) sk.cancel(); //write完就結束了, 關閉select key    }}//上面 的實現用Handler來同時處理Read和Write事件, 所以裡面出現狀態判斷//我們可以用State-Object pattern來更優雅的實現class Handler { // ...    public void run() { // initial state is reader        socket.read(input);        if (inputIsComplete()) {            process();            sk.attach(new Sender());  //狀態遷移, Read後變成write, 用Sender作為新的callback對象            sk.interest(SelectionKey.OP_WRITE);            sk.selector().wakeup();        }    }    class Sender implements Runnable {        public void run(){ // ...            socket.write(output);            if (outputIsComplete()) sk.cancel();        }    }}

這裡用到了Reactor模式。

關於Reactor模式的一些概念：

Reactor：負責響應IO事件，當檢測到一個新的事件，將其發送給相應的Handler去處理。

Handler：負責處理非阻塞的行為，標識系統管理的資源；同時將handler與事件綁定。

Reactor為單個線程，需要處理accept串連，同時發送請求到處理器中。

由於只有單個線程，所以處理器中的業務需要能夠快速處理完。

改進：使用多執行緒商務邏輯。

Worker Thread Pools

 參考代碼：

class Handler implements Runnable {    // uses util.concurrent thread pool    static PooledExecutor pool = new PooledExecutor(...);    static final int PROCESSING = 3;    // ...    synchronized void read() { // ...        socket.read(input);        if (inputIsComplete()) {            state = PROCESSING;            pool.execute(new Processer()); //使用線程pool非同步執行        }    }        synchronized void processAndHandOff() {        process();        state = SENDING; // or rebind attachment        sk.interest(SelectionKey.OP_WRITE); //process完,開始等待write事件    }        class Processer implements Runnable {        public void run() { processAndHandOff(); }    }}

將處理器的執行放入線程池，多線程進行業務處理。但Reactor仍為單個線程。

繼續改進：對於多個CPU的機器，為充分利用系統資源，將Reactor拆分為兩部分。

Using Multiple Reactors

參考代碼：

Selector[] selectors; //subReactors集合, 一個selector代表一個subReactorint next = 0;class Acceptor { // ...    public synchronized void run() { ...        Socket connection = serverSocket.accept(); //主selector負責accept        if (connection != null)            new Handler(selectors[next], connection); //選個subReactor去負責接收到的connection        if (++next == selectors.length) next = 0;    }}

mainReactor負責監聽串連，accept串連給subReactor處理，為什麼要單獨分一個Reactor來處理監聽呢？因為像TCP這樣需要經過3次握手才能建立串連，這個建立串連的過程也是要耗時間和資源的，單獨分一個Reactor來處理，可以提高效能。

 

參考：

http://www.cnblogs.com/fxjwind/p/3363329.html

 

《Scalable IO in Java》筆記