cindy源码阅读（7）Dispatcher

cindy中的Dispatcher 其实就是最后的执行了，也就是多线程的体现了。

void dispatch(Session session, Runnable event);

这个是Dispatcher 最重要的方法，可以看到还是离不开session。
Runnable 这里cindy通用的做法是调用的时候才定义具体的实现。

有两个实现类，DefaultDispatcher和DirectDispatcher。用哪个是由DispatcherFactory决定的，默认是DefaultDispatcher。

DirectDispatcher的实现：

  public void dispatch(Session session, Runnable event) {
        Queue queue = getQueue();
        queue.add(event); // enqueue

        if (queue.size() == 1) {
            event.run();
            queue.poll(); // dequeue current runnable
            for (Runnable task = null; (task = (Runnable) queue.peek()) != null; queue
                    .poll())
                task.run();
        }
    }

DirectDispatcher的实现其实很简单：就是来一个任务执行一个，没用到多线程。所以是会比较影响性能的。


DefaultDispatcher的实现：

public void dispatch(Session session, Runnable event) {
        Worker worker = null;
        synchronized (mainLock) {
            worker = getWorker(session);
        }
        if (Thread.currentThread() == worker) {
            dispatcher.dispatch(session, event);
        } else {
            BlockingQueue queue = worker.queue;
            if (!queue.offer(event)) {
                // flow control
                if (elapsedTime.getElapsedTime() >= 10000) {
                    elapsedTime.reset();
                    log.warn("dispatcher flow control");
                }
                try {
                    queue.put(event);
                } catch (InterruptedException e) {
                }
            }
        }
    }

DefaultDispatcher的实现其实就是没个session都搞了个Worker，其实就是一个线程，这样就会是多线程去处理了。

 private class Worker extends Thread {

synchronized (this) {
                            try {
                                wait(keepAliveTime);
                            } catch (InterruptedException e) {
                            }
                        }

对于Worker来说每次线程不是用完就关闭掉，为了避免线程的频繁创建和回收，线程默认会持续一段时间，如果在这个时间内同一个session的下一个请求会重用这个worker。这个时间默认是5秒。

对于DefaultDispatcher来说block方法其实就是在不同的worker重用的时候起作用，正在用的worker不能重用。
在DefaultFuture中有使用：

public boolean complete() {
        if (!completed) {
            synchronized (this) {
                while (!completed) {
                    dispatcher.block(); // block dispatcher
                    try {
                        wait();
                    } catch (InterruptedException e) {
                    }
                }
            }
        }
        return succeeded;
    }

dispatch的使用场景有：ChannelReactorHandler，DefaultFuture，DispatcherFilter。就是所有希望用到多线程的地方，都使用dispatch。