Tomcat原理系列之三：对请求的过程详细分析

public Http11NioProtocol() {
        endpoint=new NioEndpoint();//端点
        cHandler = new Http11ConnectionHandler(this);//connection处理器
        ((NioEndpoint) endpoint).setHandler(cHandler);
        setSoLinger(Constants.DEFAULT_CONNECTION_LINGER);
        setSoTimeout(Constants.DEFAULT_CONNECTION_TIMEOUT);
        setTcpNoDelay(Constants.DEFAULT_TCP_NO_DELAY);
    }

@Override
       public void run() {
           while (running) {
                   try {
                       //接收线程(没有连接时阻塞在此处)
                       socket = serverSock.accept();
                   } catch (IOException ioe) {
                   }
                   // Successful accept, reset the error delay
                   errorDelay = 0;
                   // Configure the socket
                   if (running && !paused) {
                       // setSocketOptions()======= 对socket进一步处理
                       if (!setSocketOptions(socket)) {
                           closeSocket(socket);
                       }
                   } else {
                       closeSocket(socket);
                   }
               } catch (Throwable t) {
                   ExceptionUtils.handleThrowable(t);
                   log.error(sm.getString("endpoint.accept.fail"), t);
               }
           }
           state = AcceptorState.ENDED;
       }

@Override
       public void run() {
           // Loop until destroy() is called
           while (true) {
               boolean hasEvents = false;
               try {
                   if (!close) {
                       hasEvents = events();
                       if (wakeupCounter.getAndSet(-1) > 0) {
                           //if we are here, means we have other stuff to do
                           //do a non blocking select
                           keyCount = selector.selectNow();
                       } else {
                           keyCount = selector.select(selectorTimeout);
                       }
                       wakeupCounter.set(0);
                   }
                   if (close) {
                       events();
                       timeout(0, false);
                       try {
                           selector.close();
                       } catch (IOException ioe) {
                           log.error(sm.getString("endpoint.nio.selectorCloseFail"), ioe);
                       }
                       break;
                   }
               } catch (Throwable x) {
                   ExceptionUtils.handleThrowable(x);
                   log.error("",x);
                   continue;
               }
               //either we timed out or we woke up, process events first
               if ( keyCount == 0 ) hasEvents = (hasEvents | events());
               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 attachment = (NioSocketWrapper)sk.attachment();
                   // Attachment may be null if another thread has called
                   // cancelledKey()
                   if (attachment == null) {
                       iterator.remove();
                   } else {
                       iterator.remove();
                       processKey(sk, attachment);
                   }
               }//while
               //process timeouts
               timeout(keyCount,hasEvents);
           }//while
           getStopLatch().countDown();
       }

public boolean processSocket(SocketWrapperBase<S> socketWrapper,
           SocketEvent event, boolean dispatch) {
       try {
           if (socketWrapper == null) {
               return false;
           }
           SocketProcessorBase<S> sc = processorCache.pop();
           if (sc == null) {
               sc = createSocketProcessor(socketWrapper, event);
           } else {
               sc.reset(socketWrapper, event);
           }
           Executor executor = getExecutor();
           if (dispatch && executor != null) {
               executor.execute(sc);//将socket处理任务提交到worker线程池
           } else {
               sc.run();
           }
       } catch (RejectedExecutionException ree) {
           getLog().warn(sm.getString("endpoint.executor.fail", socketWrapper) , ree);
           return false;
       } catch (Throwable t) {
           ExceptionUtils.handleThrowable(t);
           // This means we got an OOM or similar creating a thread, or that
           // the pool and its queue are full
           getLog().error(sm.getString("endpoint.process.fail"), t);
           return false;
       }
       return true;
   }

ApplicationFilterChain filterChain =
              ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);

filterChain.doFilter(request.getRequest(),
                                  response.getResponse());

servlet.service(request, response);