tomcat处理一个http请求的过程

╰半橙微兮° 2023-05-31 06:39 17阅读 0赞

以NIO方式为例讲解一下tomcat处理一个http请求的过程 （servlet）

首先http请求本质上也是建立在socket连接之上的，因此大概处理路径不外乎

> socket.accept() ---> socket流封装--->丢入Worker线程池处理----->
> 
> Container内部处理----> 最终交给Servlet处理----> 返回结果

tomcat 分为Connector和Container, Connector和Container通过适配器adaptor关联

Connector包含NioEndpoint(Acceptor,PollerEvent,Poller,SocketProcessor,ConnectionHandler)，Http11Processor,Adaptor

/**
         * Cache for poller events
         */
        private SynchronizedStack<PollerEvent> eventCache;

Acceptor : socket.accept() 监听端口，处理与客户端的交互

PollerEvent： 事件队列，Socket流的封装

Poller： 从队列中取出事件，交给SocketProcessor处理

SocketProcessor： 将Socket事件交给Worker线程处理

![Ã¨Â¿Ã©Ã¥Ã¥Â¾Ã§Ã¦Ã¨Â¿Â°][SouthEast]

各个模块的功能如下：

首先从NioEndpoint入手：

start() 启动方法

>     public final void start() throws Exception {
>         if (bindState == BindState.UNBOUND) {
>             bindWithCleanup();
>             bindState = BindState.BOUND_ON_START;
>         }
>         // 内部启动
>         startInternal();
>     }

startInternal()

>     各种组件的初始化

>     // 事件队列
>     if (socketProperties.getEventCache() != 0) {
>         eventCache = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,
>                 socketProperties.getEventCache());
>     }
> 
> \--------------------------------------------------------------------------------------------------------------------
> 
> // worker线程池
> 
>     // Create worker collection
>     if (getExecutor() == null) {
>         createExecutor();
>     }
>     // 限制连接数
>     initializeConnectionLatch();
>     
>     // Start poller thread
>     poller = new Poller();
>     Thread pollerThread = new Thread(poller, getName() + "-ClientPoller");
>     pollerThread.setPriority(threadPriority);
>     pollerThread.setDaemon(true);
>     pollerThread.start();
>     // accept线程
>     startAcceptorThread();

Poller逻辑

>     private Selector selector;
>     private final SynchronizedQueue<PollerEvent> events =
>             new SynchronizedQueue<>();

run()方法

>     Iterator<SelectionKey> iterator =
>         keyCount > 0 ? selector.selectedKeys().iterator() : null;
>     // Walk through the collection of ready keys and dispatch
>     // any active event.
>     while (iterator != null && iterator.hasNext()) {
>         SelectionKey sk = iterator.next();
>         NioSocketWrapper socketWrapper = (NioSocketWrapper) sk.attachment();
>         // Attachment may be null if another thread has called
>         // cancelledKey()
>         if (socketWrapper == null) {
>             iterator.remove();
>         } else {
>             iterator.remove();
>             // 处理socketWrapper
>             processKey(sk, socketWrapper);
>         }
>     }

>     public boolean processSocket(SocketWrapperBase<S> socketWrapper,
>             SocketEvent event, boolean dispatch) {
>         try {
>             ....
>             SocketProcessorBase<S> sc = null;
>             if (processorCache != null) {
>                 sc = processorCache.pop();
>             }
>             // 创建SocketPRocessor
>             if (sc == null) {
>                 sc = createSocketProcessor(socketWrapper, event);
>             } else {
>                 sc.reset(socketWrapper, event);
>             }
>              
>             Executor executor = getExecutor();
>             if (dispatch && executor != null) {
>                 // 线程池处理
>                 executor.execute(sc);
>             }
> 
>

createSocketProcessor() 实例化`SocketProcessor`

>     @Override
>     protected SocketProcessorBase<NioChannel> createSocketProcessor(
>             SocketWrapperBase<NioChannel> socketWrapper, SocketEvent event) {
>         return new SocketProcessor(socketWrapper, event);
>     }
> 
>

doRun()

>     //  ConnectionHandler处理
>         state = getHandler().process(socketWrapper, event);

ConnectionHandler的process方法

>     SocketState state = SocketState.CLOSED;
>     do {
>         state = processor.process(wrapper, status);

`processor为` AbstractProcessorLight

`process`()

>     if (state == SocketState.OPEN) {
>         // There may be pipe-lined data to read. If the data isn't
>         // processed now, execution will exit this loop and call
>         // release() which will recycle the processor (and input
>         // buffer) deleting any pipe-lined data. To avoid this,
>         // process it now.
>         state = service(socketWrapper);
>     }

Http11Processor的service()

>     getAdapter().service(request, response);

>  
> 
>     rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
>     if (!getAdapter().asyncDispatch(request, response, status)) {
>         setErrorState(ErrorState.CLOSE_NOW, null);
>     }

getAdapter()为CoyoteAdapter适配器，适配Connetor和Containner

>     connector.getService().getContainer().getPipeline().getFirst().invoke(
>             request, response);

Container通过Engine--> Host--> Context-->Wrapper-->Servlet，最终交给Servlet处理

Tomcat业务线程池源码（AbstractEndpoint类）默认最少启动10个线程，最大200个

>     public void createExecutor() {
>         internalExecutor = true;
>         TaskQueue taskqueue = new TaskQueue();
>         TaskThreadFactory tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
>         executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS,taskqueue, tf);
>         taskqueue.setParent( (ThreadPoolExecutor) executor);
>     }

[SouthEast]: /images/20230531/57d3e3699f2d467a9240d681286a12e8.png