解读Tomcat（四）：请求处理解析Part_2

/**
*作者:annegu
*日期:2009-06-22
*/

3、SocketProcessor：这个类是真正处理用户请求的类。
我们只看最重要的一步，如何处理channel：

boolean closed = (status==null)?(handler.process(socket)==Handler.SocketState.CLOSED) : (handler.event(socket,status)==Handler.SocketState.CLOSED);

这里的handler是Http11NioProtocal里面的一个子类Http11ConnectionHandler。在这里对于这个socket有没有状态是分开处理的，还记得前面的processKey()方法里面，有好几处的if-else，有三个分支处都调用了processSocket()，有的是有status的，有的只有一个socket传进去，分别就在此处。其实大体都差不多，所以，我们就着重来看看handler.process()吧。

不管怎么样，我们首先都要得到一个processor对象，这个processor也是从一个可回收的数组中取出来的，然后主要的是调用processor的process方法。

SocketState state = processor.process(socket);

在Http11NioProcessor的process方法就是用来从channel里面把字节流读出来，然后把它转换成容器需要的request和response对象（通过inputBuffer的parseRequestLine, parseRequest等方法来实现这个功能的）。然后，封装好了request，并且也创建好了response之后，会用adapter.service(request, response);来把request和response传递进context。

public SocketState process(NioChannel socket){
if (!error) {
     try {
adapter.service(request, response);
...
         }
     }
}

这个service方法中我们只关注下面一段。

      req.getRequestProcessor().setWorkerThreadName(Thread.currentThread().getName());
            if (postParseRequest(req, request, res, response)) {
                connector.getContainer().getPipeline().getFirst().invoke(request, response);
}

好了，我们看到，第一步就是给这个request设置处理它的线程。第二步，在这个里面会对request进行一些处理，譬如说sessionId就是在这里处理的，通过parstSessionId把sessionId设置到request里面。第三步，就开始调用container了，接下来的过程anne我打算后面慢慢分解。

4、在NioEndpoint类中还有个子类叫做WorkerStack，这是一个存放Worker的堆栈。
前面在讲到调用processSocket方法的时候，说从这里开始要取线程池中的线程了，如果使用了executor，那么线程池就使用java自带的线程池，如果不使用executor的话，就使用tomcat的线程池WorkerStack。

public class WorkerStack {
        protected Worker[] workers = null;
        protected int end = 0;
        public WorkerStack(int size) {
            workers = new Worker[size];
        }
        public void push(Worker worker) {
            workers[end++] = worker;
        }
        public Worker pop() {
            if (end > 0) {
                return workers[--end];
            }
            return null;
        }
...
}

Workers[]当然不用说，是一个Worker对象的数组，end则是数组中Worker的个数。这都非常好理解。现在的问题就是Worker。Worker是用来处理socket的工具。
首先我们要通过getWorkerThread()来得到一个Worker对象，怎么的到呢，先看看workerStack里面有没有空闲的Worker啊，有的话最好，直接就拿出来了，没有的话，就新建一个呗，万一这么倒霉，线程数已经到顶了，不能新建了，那就请先稍微等等，等到有了空闲的worker，就唤醒getWorkerThread()方法。代码如下：

    protected Worker getWorkerThread() {
        Worker workerThread = createWorkerThread();
        while (workerThread == null) {
            try {
                synchronized (workers) {
                    workerThread = createWorkerThread();
                    if ( workerThread == null ) workers.wait();
                }
            } catch (InterruptedException e) {
                // Ignore
            }
            if ( workerThread == null ) workerThread = createWorkerThread();
        }
        return workerThread;
    }

顺便看一下如何唤醒等待worker的线程。

    protected void recycleWorkerThread(Worker workerThread) {
        synchronized (workers) {
            workers.push(workerThread);
            curThreadsBusy--;
            workers.notify();
        }
   }

好了，到这里客户端请求的接收就讲完了，当然，anne没有忘记这个过程只到进入container，但大体上我们已经知道inputStream已经变成request了，接下来就要经过engine, host, context的洗礼，最后目标就是servlet。
呃，我还画了一个时序图，虽然比较简陋，但图文并茂的话看起来比较省力。



现在我们脑补一下，假设这个请求servlet已经处理结束了，现在我们要把这个response返回给客户端了！

之前在讲到Http11NioProcessor的process方法的时候，我们知道就是在process里面调用了adapter.service()，这个方法很明显是request进入容器的入口，那么出口是不是也在这里呢，我们在process方法里面往下找找，就可以看到：

    if (sendfileData != null && !error) {
    	      KeyAttachment ka = (KeyAttachment)socket.getAttachment(false);
           ka.setSendfileData(sendfileData);
           sendfileData.keepAlive = keepAlive;
           SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());
           openSocket = socket.getPoller().processSendfile(key,ka,true);
           break;
}

最后的break我们不管，关键是我们看到从key attachement中取出了senfileData，然后调用了Poller的processSendfile()。我们已经知道了，Poller就是NIO中的主线程，现在又跑到主线程中去了，它要做什么呢？

        public boolean processSendfile(SelectionKey sk, KeyAttachment attachment, boolean reg) {
            try {
                SendfileData sd = attachment.getSendfileData();
				...//ignore
                if ( sd.length <= 0 ) {
                    attachment.setSendfileData(null);
                    if ( sd.keepAlive ) {
      ①                if (reg) reg(sk,attachment,SelectionKey.OP_READ);
                    } else {
                        cancelledKey(sk,SocketStatus.STOP,false);
                    }
                } else if ( attachment.interestOps() == 0 && reg ) {
      ②              reg(sk,attachment,SelectionKey.OP_WRITE);
                }
            }catch ( IOException x ) {
                cancelledKey(sk,SocketStatus.ERROR,false);
                return false;
            }catch ( Throwable t ) {
                cancelledKey(sk, SocketStatus.ERROR, false);
                return false;
            }
            return true;
        }

我们可以看到在代码①处和②处（不同的分支），都又调用reg方法，这个意思是告诉操作系统要对channel进行读（写）操作了。

关于对channel的读写操作，NIO 有一个主要的类Selector，这个类似一个观察者，只要我们把需要观察的socket channel告诉Selector，那么当有我们感兴趣的事件发生时，selector就会通知我们，并且传回一组SelectionKey，通过读取这些selection key，我们就可以的到刚才注册过的channel，进而得到channel中的字节流了。Selector的内部原理实际上是一直在对注册的channel进行轮询访问，一旦轮询到一个channel有我们感兴趣的事情发生（比如数据来了），selector就会报告返回这个channel的selection key，让我们通过这个selection key来读取对应channel的内容。

我们已经知道了selection key是对应channel的一把钥匙，之间的代码中我们有看到selection key有isReadalbe和isWriteable两种状态，这个状态是针对主线程（也就是poller）来说的，它告诉主线程现在这个channel是可读的，或者可写的。而出现在代码①处和②处这里的OP_READ和OP_WRITE则是用来告诉给操作系统要做的操作。SelectionKey中的operation有四种：OP_READ, OP_WRITE, OP_CONNECT, OP_ACCEPT。这些状态是由主线程告诉给操作系统要进行操作了。例如reg(sk,attachment,SelectionKey.OP_READ)，这个意思就是告诉操作系统要去socket读取数据了，把读入的数据放入到channel中；reg(sk,attachment,SelectionKey.OP_WRITE)，就是告诉操作系统现在channel中的数据都已经准备好了，现在可以往客户端写了；同理，OP_CONNECT和OP_ACCEPT分别表示结束连接和接受连接。  
 

    public static final int OP_READ = 1 << 0;
    public static final int OP_WRITE = 1 << 2; 
    public static final int OP_CONNECT = 1 << 3; 
public static final int OP_ACCEPT = 1 << 4;

    public final boolean isReadable() {
	return (readyOps() & OP_READ) != 0;
}

    public final boolean isWritable() {
	return (readyOps() & OP_WRITE) != 0;
}

上面的代码是从SelectionKey类中节选的，我们可以看到OP_READ, OP_WRITE, OP_CONNECT, OP_ACCEPT与isReadable()和isWritable()有着密切的联系。从四个操作的定义我们不难看出，ms这四个操作分别代表了一个字节中的四个位置，一个字节中有8个bit，00000001代表read，00000100代表write，00001000代表connect，00010000代表accept。
拿read来举例，假如这时候我们打算让某个channel去读取客户端数据，那么我们就给这个channel注册OP_READ事件，reg(sk,attachment,SelectionKey.OP_READ)。

protected void reg(SelectionKey sk, KeyAttachment attachment, int intops) {
     sk.interestOps(intops); 
     attachment.interestOps(intops);
}

现在这个channel的interestOps就是00000001。
readyOps()表示的是这个channel当前准备好的状态。假如操作系统还没有给这个channel进行读操作，那么readyOps()当然在代表read的那一位是0了，假如操作系统已经把这个channel中填充了客户端来的数据了，那么就把read这位置为1，这个时候readyOps()就变成了00000001了，那么(readyOps() & OP_READ)就=1啦，表示这个channel现在是isReadable的，所以接下来主线程就可以从这个channel中读取数据了。
我们可以看一下下面的图示。



好了，下一部分，我们就要来看进入engine之后的情况了，就是从connector.getContainer().getPipeline().getFirst().invoke(request, response)开始。