tomcat4.0那些优秀的代码

青旅半醒 2022-11-06 06:49 140阅读 0赞

当连接器接收到连接时，会去获取http处理器

在这里连接器是单线程的，http处理器是多线程的。

org.apache.catalina.connector.http.HttpConnector\#run

public void run() {
            // Loop until we receive a shutdown command
            while (!stopped) {
                // Accept the next incoming connection from the server socket
                Socket socket = null;
                try {
                    //                if (debug >= 3)
                    //                    log("run: Waiting on serverSocket.accept()");
                    socket = serverSocket.accept();
                    //                if (debug >= 3)
                    //                    log("run: Returned from serverSocket.accept()");
                    if (connectionTimeout > 0)
                        socket.setSoTimeout(connectionTimeout);
                    socket.setTcpNoDelay(tcpNoDelay);
                } catch (AccessControlException ace) {
                    log("socket accept security exception", ace);
                    continue;
                } catch (IOException e) {
                    //                if (debug >= 3)
                    //                    log("run: Accept returned IOException", e);
                    try {
                        // If reopening fails, exit
                        synchronized (threadSync) {
                            if (started && !stopped)
                                log("accept error: ", e);
                            if (!stopped) {
                                //                    if (debug >= 3)
                                //                        log("run: Closing server socket");
                                serverSocket.close();
                                //                        if (debug >= 3)
                                //                            log("run: Reopening server socket");
                                serverSocket = open();
                            }
                        }
                        //                    if (debug >= 3)
                        //                        log("run: IOException processing completed");
                    } catch (IOException ioe) {
                        log("socket reopen, io problem: ", ioe);
                        break;
                    } catch (KeyStoreException kse) {
                        log("socket reopen, keystore problem: ", kse);
                        break;
                    } catch (NoSuchAlgorithmException nsae) {
                        log("socket reopen, keystore algorithm problem: ", nsae);
                        break;
                    } catch (CertificateException ce) {
                        log("socket reopen, certificate problem: ", ce);
                        break;
                    } catch (UnrecoverableKeyException uke) {
                        log("socket reopen, unrecoverable key: ", uke);
                        break;
                    } catch (KeyManagementException kme) {
                        log("socket reopen, key management problem: ", kme);
                        break;
                    }
    
                    continue;
                }
    
                // Hand this socket off to an appropriate processor
                HttpProcessor processor = createProcessor(); // 创建（新创建的没有放大stack 中）或者取到httpProcessor. 并且调用生命周期方法。初始化线程后台等待socket。
                if (processor == null) {
                    try {
                        log(sm.getString("httpConnector.noProcessor"));
                        socket.close();
                    } catch (IOException e) {
                        ;
                    }
                    continue;
                }
                //            if (debug >= 3)
                //                log("run: Assigning socket to processor " + processor);
                //释放processor通知
                processor.assign(socket);
    
                // The processor will recycle itself when it finishes
    
            }
    
            // Notify the threadStop() method that we have shut ourselves down
            //        if (debug >= 3)
            //            log("run: Notifying threadStop() that we have shut down");
            synchronized (threadSync) {
                threadSync.notifyAll();
            }
    
        }

创建并获取http处理器

private HttpProcessor createProcessor() {
    
            synchronized (processors) {
                if (processors.size() > 0) {
                    // if (debug >= 2)
                    // log("createProcessor: Reusing existing processor");
                    return ((HttpProcessor) processors.pop());
                }
                if ((maxProcessors > 0) && (curProcessors < maxProcessors)) {
                    // if (debug >= 2)
                    // log("createProcessor: Creating new processor");
                    return (newProcessor());
                } else {
                    if (maxProcessors < 0) {
                        // if (debug >= 2)
                        // log("createProcessor: Creating new processor");
                        return (newProcessor());
                    } else {
                        // if (debug >= 2)
                        // log("createProcessor: Cannot create new processor");
                        return (null);
                    }
                }
            }
    
        }

唤醒http处理器处理socket

org.apache.catalina.connector.http.HttpProcessor\#assign

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();
    
            if ((debug >= 1) && (socket != null))
                log(" An incoming request is being assigned");
    
        }

而http连接器出生起，就在waitsocket

public void run() {
    
            // Process requests until we receive a shutdown signal
            while (!stopped) {
    
                // Wait for the next socket to be assigned，线程阻塞等待。socket
                Socket socket = await();
                if (socket == null)
                    continue;
    
                // Process the request from this socket
                try {
                    process(socket);
                } catch (Throwable t) {
                    log("process.invoke", t);
                }
    
                // Finish up this request。讲对象重新放入stack中
                //入栈
                connector.recycle(this);
    
            }
    
            // Tell threadStop() we have shut ourselves down successfully
            //用于stop
            synchronized (threadSync) {
                threadSync.notifyAll();
            }
    
        }

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();
    
            if ((debug >= 1) && (socket != null))
                log("  The incoming request has been awaited");
    
            return (socket);
    
        }

tomcat破坏了双亲委派机制，通过自定义类加载器实现了每个独立项目的隔离，通过为每个jsp设置类加载器，卸载的时候实现热加载。