tomcat 分配请求之——socket获取请求

首先，安装，调试tomcat的源码：

http://smiky.iteye.com/blog/613151

写得很全。

=========================================================
     主要描述下 tomcat如何接收请求，并分发处理的，里面有一些线程处理的细节。挺值得品味的

 

tomcat 等待用户请求的类：

 protected class Acceptor implements Runnable {

        /**
         * The background thread that listens for incoming TCP/IP connections and hands them off to an appropriate
         * processor.
         */
        public void run() {

            // Loop until we receive a shutdown command
            while (running) {

                // Loop if endpoint is paused
                while (paused) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // Ignore
                    }
                }

                // Accept the next incoming connection from the server socket
                try {
                    // 这里等待用户的请求进入，线程会阻塞，直到等到用户的请求为止
                    Socket socket = serverSocketFactory.acceptSocket(serverSocket);
                    serverSocketFactory.initSocket(socket);
                    // Hand this socket off to an appropriate processor
                    if (!processSocket(socket)) {
                        // Close socket right away
                        try {
                            socket.close();
                        } catch (IOException e) {
                            // Ignore
                        }
                    }
                } catch (IOException x) {
                    if (running) log.error(sm.getString("endpoint.accept.fail"), x);
                } catch (Throwable t) {
                    log.error(sm.getString("endpoint.accept.fail"), t);
                }

                // The processor will recycle itself when it finishes

            }

        }

    }

 

processSocket方法：

    /**
     * Process given socket.
     */
    protected boolean processSocket(Socket socket) {
        try {
            if (executor == null) {
                // 没有线程池队列，从WorkStack中获取一个，并分配给他做操作(WorkStack相当于线程池的作用)
                getWorkerThread().assign(socket);
            } else {
                // 有线程池队列，直接new 一个SocketProcessor对这个socket连接做处理
                executor.execute(new SocketProcessor(socket));
            }
        } catch (Throwable t) {
            // This means we got an OOM or similar creating a thread, or that
            // the pool and its queue are full
            log.error(sm.getString("endpoint.process.fail"), t);
            return false;
        }
        return true;
    }

 

工人类：

 protected class Worker implements Runnable {

        protected Thread  thread    = null;
        protected boolean available = false;
        protected Socket  socket    = null;

        /**
         * Process an incoming TCP/IP connection on the specified socket. Any exception that occurs during processing
         * must be logged and swallowed. <b>NOTE</b>: This method is called from our Connector's thread. We must assign
         * it to our own thread so that multiple simultaneous requests can be handled.
         * 
         * @param socket TCP socket to process
         */
        synchronized void assign(Socket socket) {

            // Wait for the Processor to get the previous Socket
            while (available) {
                // 当前Worker是否处于可用状态
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }

            // Store the newly available Socket and notify our thread
            this.socket = socket;
            available = true;
            notifyAll();

        }

        /**
         * Await a newly assigned Socket from our Connector, or <code>null</code> if we are supposed to shut down.
         */
        private synchronized Socket await() {

            // 如果处于闲置状态，就等待新的任务分配
            while (!available) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }

            // Notify the Connector that we have received this Socket
            Socket socket = this.socket;
            available = false;
            notifyAll();

            return (socket);

        }

        /**
         * The background thread that listens for incoming TCP/IP connections and hands them off to an appropriate
         * processor.
         */
        public void run() {

            // Process requests until we receive a shutdown signal
            while (running) {

                // Wait for the next socket to be assigned
                Socket socket = await();
                if (socket == null) continue;

                // 处理该次请求
                if (!setSocketOptions(socket) || !handler.process(socket)) {
                    // Close socket
                    try {
                        socket.close();
                    } catch (IOException e) {
                    }
                }

                // Finish up this request
                socket = null;
                // 回收该线程池的使用
                recycleWorkerThread(this);

            }

        }

 

 以上代码的大致示意图：