摘要：基本上所有的網絡應用都會示范一個的寫法。除了這些操作的主體是而不是，操作的是，而不是。以為例其過程是這樣的這段代碼就是創建一個，并注冊一個，并把附著到上。關鍵之一顯然是利用了協程的和，把回調轉換成順序的邏輯執行。

基本上所有的網絡應用都會示范一個tcp的echo寫法。前面我們已經看到了如何使用協程和異步io來做tcp服務器的第一步，accept。下面是一個完整的echo server的實現（完整代碼）：

package org.github.taowen.daili;

import kilim.Pausable;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

public class Main {
    public static void main(String[] args) throws Exception {
        Scheduler scheduler = new Scheduler();
        DailiTask task = new DailiTask(scheduler) {
            @Override
            public void execute() throws Pausable, Exception {
                ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
                serverSocketChannel.socket().bind(new InetSocketAddress(9090));
                serverSocketChannel.configureBlocking(false);
                System.out.println("listening...");
                scheduler.timeout = 5000;
                SocketChannel socketChannel = scheduler.accept(serverSocketChannel);
                socketChannel.configureBlocking(false);
                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024);
                while (scheduler.read(socketChannel, byteBuffer) > 0) {
                    byteBuffer.flip();
                    scheduler.write(socketChannel, byteBuffer);
                    byteBuffer.clear();
                }
            }
        };
        scheduler.callSoon(task);
        scheduler.loop();
    }
}

從上面的代碼來看，完全沒有異步IO的感覺，代碼寫出來和傳統Java同步網絡編碼是一樣的。除了scheduler.accept,scheduler.read這些操作的主體是scheduler而不是socket，操作的是byte buffer，而不是input/output stream。
這段代碼中最關鍵的是其中的那個task，是一個協程。scheduler.accept，read和accept三處會引起task的跳出執行，跳出的時候會把task當前在做的IO等待記錄到內部的一個叫SelectorBooking的身上。以readBlocked為例其過程是這樣的：

public int read(SocketChannel socketChannel, ByteBuffer byteBuffer) throws IOException, Pausable {
    int bytesCount = socketChannel.read(byteBuffer);
    if (bytesCount > 0) {
        return bytesCount;
    }
    SelectionKey selectionKey = socketChannel.keyFor(selector);
    if (null == selectionKey) {
        selectionKey = socketChannel.register(selector, SelectionKey.OP_READ);
        SelectorBooking booking = addSelectorBooking(selectionKey);
        selectionKey.attach(booking);
    } else {
        selectionKey.interestOps(selectionKey.interestOps() | SelectionKey.OP_READ);
    }
    SelectorBooking booking = (SelectorBooking) selectionKey.attachment();
    booking.readBlocked(getCurrentTimeMillis() + timeout);
    return socketChannel.read(byteBuffer);
}

這段代碼就是創建一個SelectorBooking，并注冊一個SelectionKey，并把booking附著到selection key上。這樣selection key被select出來之后，就可以根據booking找到對應喚醒的task。注意的是selection key是一個socket一個的，但是可能對應的有四個操作（accept/connect/read/write），所以booking上可能會有四個被阻塞掛起的task分別對應不同的操作。
而booking和task的交互發生在booking.readBlocked這個調用內部：

public void readBlocked(long deadline) throws Pausable {
    if (null != readTask) {
        throw new RuntimeException("multiple read blocked on same channel");
    }
    readDeadline = deadline;
    updateDeadline();
    readTask = Task.getCurrentTask();
    Task.pause(this);
    if (readDeadline == -1) {
        readUnblocked();
        throw new RuntimeException("timeout");
    }
}

其中 Task.getCurrentTask 是一個神奇的調用。它可以得到當前的“協程”。得到的這個協程可以在掛起之后調用resume重新喚醒。
Task.pause 是另外一處神奇的調用。它使得當前執行的協程掛起。等到下面那行if被執行到，已經是別的地方調用resume之后的事情了。
通過這樣的一些列操作，就完成一個協程的掛起，并把協程和異步io等信息注冊到selector上的過程。
主循環只需要調用selector，找到就緒了的selection key，然后根據之前attach的附件找到booking，通過booking找到需要喚醒的協程，然后調用resume就可以讓協程上的業務邏輯繼續往下執行了：

public void loop() {
    while (loopOnce()) {
    }
}

boolean loopOnce() {
    try {
        executeReadyTasks();
        doSelect();
        Iterator iterator = selector.selectedKeys().iterator();
        ioUnblocked(iterator);
        while (hasDeadSelectorBooking()) {
            SelectorBooking booking = selectorBookings.poll();
            booking.cancelDeadTasks(getCurrentTimeMillis());
        }
        return true;
    } catch (Exception e) {
        LOGGER.error("loop died", e);
        return false;
    }
}

這種做法非常經典。關鍵之一顯然是利用了協程的pause和resume，把回調轉換成順序的邏輯執行。關鍵之二就是利用了selection key的附件功能，把協程附著到了selection key上從而在select出來之后可以迅速恢復到阻塞之前的程序狀態（resume是一個局部上下文恢復的過程）。