从连接器组件看Tomcat的线程模型——BIO模式(推荐)

@Configuration
public class TomcatConfig {

 @Bean
 public WebServerFactoryCustomizer tomcatCustomer() {
  return new TomcatCustomerConfig();
 }

 public class TomcatCustomerConfig implements WebServerFactoryCustomizer {
  @Override
  public void customize(TomcatServletWebServerFactory factory) {
   if (factory != null) {
    factory.setProtocol("org.apache.coyote.http11.Http11Protocol");
   }
  }
 }
}

@Override
public void bind() throws Exception {

 // Initialize thread count defaults for acceptor
 if (acceptorThreadCount == 0) {
  acceptorThreadCount = 1;
 }
 // Initialize maxConnections
 if (getMaxConnections() == 0) {
  // User hasn't set a value - use the default
  setMaxConnections(getMaxThreadsWithExecutor());
 }

 if (serverSocketFactory == null) {
  if (isSSLEnabled()) {
   serverSocketFactory =
    handler.getSslImplementation().getServerSocketFactory(this);
  } else {
   serverSocketFactory = new DefaultServerSocketFactory(this);
  }
 }
 //这边做了ServerSocket的端口绑定
 if (serverSocket == null) {
  try {
   if (getAddress() == null) {
    //没指定具体地址，Tomcat会监听所有地址过来的请求
    serverSocket = serverSocketFactory.createSocket(getPort(),
                getBacklog());
   } else {
    //指定了具体地址，Tomcat只监听这个地址过来的请求
    serverSocket = serverSocketFactory.createSocket(getPort(),
                getBacklog(), getAddress());
   }
  } catch (BindException orig) {
   String msg;
   if (getAddress() == null)
    msg = orig.getMessage() + " :" + getPort();
   else
    msg = orig.getMessage() + " " +
    getAddress().toString() + ":" + getPort();
   BindException be = new BindException(msg);
   be.initCause(orig);
   throw be;
  }
 }

}

public void startInternal() throws Exception {

 if (!running) {
  running = true;
  paused = false;

  //创建线程池
  if (getExecutor() == null) {
   createExecutor();
  }
  //创建ConnectionLatch
  initializeConnectionLatch();
  //创建accept线程，这个线程是请求处理的初始线程
  startAcceptorThreads();
  // Start async timeout thread
  Thread timeoutThread = new Thread(new AsyncTimeout(),
           getName() + "-AsyncTimeout");
  timeoutThread.setPriority(threadPriority);
  timeoutThread.setDaemon(true);
  timeoutThread.start();
 }
}

protected final void startAcceptorThreads() {
 int count = getAcceptorThreadCount();
 acceptors = new Acceptor[count];
 //根据配置，设置一定数量的accept线程
 for (int i = 0; i 

protected class Acceptor extends AbstractEndpoint.Acceptor {

  @Override
  public void run() {

   int errorDelay = 0;
   // Loop until we receive a shutdown command
   while (running) {
    // Loop if endpoint is paused
    while (paused && running) {
     state = AcceptorState.PAUSED;
     try {
      Thread.sleep(50);
     } catch (InterruptedException e) {
      // Ignore
     }
    }

    if (!running) {
     break;
    }
    state = AcceptorState.RUNNING;

    try {
     //if we have reached max connections, wait
     //达到连接上限，acceptor线程进入等待状态，直到其他线程释放,这是一种简单的通过连接数量进行流量控制的手段
     //通过实现AQS组件实现（LimitLatch），思路是先初始化同步器的最大限制值，然后每接收一个套接字就将计数变量累加1，每关闭一个套接字将计数变量减1
     countUpOrAwaitConnection();
     Socket socket = null;
     try {
      //accept下个socket连接，如果一直没有连接过来这个方法阻塞
      socket = serverSocketFactory.acceptSocket(serverSocket);
     } catch (IOException ioe) {
      //有异常的话释放一个连接数
      countDownConnection();
      errorDelay = handleExceptionWithDelay(errorDelay);
      throw ioe;
     }
     // Successful accept, reset the error delay
     errorDelay = 0;
     //对socket进行适当配置
     if (running && !paused && setSocketOptions(socket)) {
      // 处理这个socket请求，这边也是重点。
      if (!processSocket(socket)) {
       countDownConnection();
       // Close socket right away
       closeSocket(socket);
      }
     } else {
      countDownConnection();
      // Close socket right away
      closeSocket(socket);
     }
    } catch (IOException x) {
     if (running) {
      log.error(sm.getString("endpoint.accept.fail"), x);
     }
    } catch (NullPointerException npe) {
     if (running) {
      log.error(sm.getString("endpoint.accept.fail"), npe);
     }
    } catch (Throwable t) {
     ExceptionUtils.handleThrowable(t);
     log.error(sm.getString("endpoint.accept.fail"), t);
    }
   }
   state = AcceptorState.ENDED;
  }
 }

protected class SocketProcessor implements Runnable {
 //进行Debug调试的时候可以从这个类的run方法开始调试
	@Override
 public void run() { 
 	//对套接字进行处理并输出响应
  //对连接限流器LimitLatch减一
  //关闭套接字
 }
}