Tomcat源码---请求处理(接收,线程分配)一

一,在以上文章中tomcat启动已经完毕,接着要做的是消息的请求与响应

以下是tomcat文档中的详解

-----------------------------------------------------------------------------------------------

 

d) Tomcat receives a request on an HTTP port

   d1) The request is received by a separate thread which is waiting in the PoolTcpEndPoint 

        class. It is waiting for a request in a regular ServerSocket.accept() method.

        When a request is received, this thread wakes up.

   d2) The PoolTcpEndPoint assigns the a TcpConnection to handle the request. 

       It also supplies a JMX object name to the catalina container (not used I believe)

   d3) The processor to handle the request in this case is Coyote Http11Processor, 

       and the process method is invoked.

       This same processor is also continuing to check the input stream of the socket

       until the keep alive point is reached or the connection is disconnected.

   d4) The HTTP request is parsed using an internal buffer class (Coyote Http11 Internal Buffer)

       The buffer class parses the request line, the headers, etc and store the result in a 

       Coyote request (not an HTTP request) This request contains all the HTTP info, such

       as servername, port, scheme, etc.

   d5) The processor contains a reference to an Adapter, in this case it is the 

       Coyote Tomcat 5 Adapter. Once the request has been parsed, the Http11 processor

       invokes service() on the adapter. In the service method, the Request contains a 

       CoyoteRequest and CoyoteRespons (null for the first time)

       The CoyoteRequest(Response) implements HttpRequest(Response) and HttpServletRequest(Response)

       The adapter parses and associates everything with the request, cookies, the context through a 

       Mapper, etc

   d6) When the parsing is finished, the CoyoteAdapter invokes its container (StandardEngine)

       and invokes the invoke(request,response) method.

       This initiates the HTTP request into the Catalina container starting at the engine level

   d7) The StandardEngine.invoke() simply invokes the container pipeline.invoke()

   d8) By default the engine only has one valve the StandardEngineValve, this valve simply

       invokes the invoke() method on the Host pipeline (StandardHost.getPipeLine())

   d9) the StandardHost has two valves by default, the StandardHostValve and the ErrorReportValve

   d10) The standard host valve associates the correct class loader with the current thread

        It also retrives the Manager and the session associated with the request (if there is one)

        If there is a session access() is called to keep the session alive

   d11) After that the StandardHostValve invokes the pipeline on the context associated

        with the request.

   d12) The first valve that gets invoked by the Context pipeline is the FormAuthenticator

        valve. Then the StandardContextValve gets invoke.

        The StandardContextValve invokes any context listeners associated with the context.

        Next it invokes the pipeline on the Wrapper component (StandardWrapperValve)

   d13) During the invokation of the StandardWrapperValve, the JSP wrapper (Jasper) gets invoked

        This results in the actual compilation of the JSP.

        And then invokes the actual servlet.

e) Invokation of the servlet class

 

-----------------------------------------------------------------------------------------------

 

消息接收是从org.apache.tomcat.util.net.JIoEndpoint$Acceptor#run 这是tomcat接收请求的开始

 

 /**
         * 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 {
              //serversocket执行accept()同意请求
                    Socket socket = serverSocketFactory.acceptSocket(serverSocket);
                    serverSocketFactory.initSocket(socket);
                    // Hand this socket off to an appropriate processor
                    //对scoket进行处理
                    if (!processSocket(socket)) {
                        // Close socket right away
                        try {//响应完毕,关闭socket
                            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

            }

        }

    }

 JIoEndpoint#processSocket(socket)

 

 

 /**
     * Process given socket.
     */
    protected boolean processSocket(Socket socket) {
        try {
           //没有线程池时使用默认提供的,以下对这一步进行详解
            if (executor == null) {
                getWorkerThread().assign(socket);
            } else {
                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;
    }

 

  getWorkerThread().assign(socket);

 分为两步,getWorkerThread()获取到JIoEndpoint$Worker#run(),这一步在线程池中获取到一个线程并启动它

 

 protected Worker createWorkerThread() {

        synchronized (workers) {
            if (workers.size() > 0) {
                curThreadsBusy++;
                return workers.pop();
            }
            if ((maxThreads > 0) && (curThreads < maxThreads)) {
                curThreadsBusy++;
                if (curThreadsBusy == maxThreads) {
                    log.info(sm.getString("endpoint.info.maxThreads",
                            Integer.toString(maxThreads), address,
                            Integer.toString(port)));
                }
               //从线程中取出线程
                return (newWorkerThread());
            } else {
                if (maxThreads < 0) {
                    curThreadsBusy++;
                    return (newWorkerThread());
                } else {
                    return (null);
                }
            }
        }

    }
---------------------------------------------------------------- 
  //启动线程
   protected Worker newWorkerThread() {

        Worker workerThread = new Worker();
        workerThread.start();
        return (workerThread);

    }

 

   getWorkerThread().assign(socket);这一步中为线程分配socket,使用了同步锁机制

 

      //这个是在Acceptor线程中执行的
        synchronized void assign(Socket socket) {

            // Wait for the Processor to get the previous Socket
            while (available) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }

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

        }

        
  ------------------------------------------------------------
 //这一步是在Worker线程#run中调用的
        private synchronized Socket await() {

            // Wait for the Connector to provide a new Socket
            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);

        }
//以上两个方法,是两个线程的执行,等待先对socket赋值再执行

 现在到JIoEndpoint$Worker#run

 

        /**
         * 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 socket = await();
                if (socket == null)
                    continue;

                // Process the request from this socket
                //以下的handler.process(socket)才是真正的对socket开始进行处
               //以上所做的只是分配而已,handler是在                 //org.apache.coyote.http11.Http11Protocol(implements ProtocolHandler)#init
                if (!setSocketOptions(socket) || !handler.process(socket)) {
                    // Close socket
                    try {
                        socket.close();
                    } catch (IOException e) {
                    }
                }

                // Finish up this request
                socket = null;
                recycleWorkerThread(this);//进行回收线程

            }

        }