從連接器組件看Tomcat的線程模型——BIO模式(推薦)

@Configuration
public class TomcatConfig {

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

 public class TomcatCustomerConfig implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
  @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會監(jiān)聽所有地址過來的請求
    serverSocket = serverSocketFactory.createSocket(getPort(),
                getBacklog());
   } else {
    //指定了具體地址，Tomcat只監(jiān)聽這個地址過來的請求
    serverSocket = serverSocketFactory.createSocket(getPort(),
                getBacklog(), getAddress());
   }
  } catch (BindException orig) {
   String msg;
   if (getAddress() == null)
    msg = orig.getMessage() + " <null>:" + 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;

  //創(chuàng)建線程池
  if (getExecutor() == null) {
   createExecutor();
  }
  //創(chuàng)建ConnectionLatch
  initializeConnectionLatch();
  //創(chuàng)建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];
 //根據(jù)配置，設置一定數(shù)量的accept線程
 for (int i = 0; i < count; i++) {
  acceptors[i] = createAcceptor();
  String threadName = getName() + "-Acceptor-" + i;
  acceptors[i].setThreadName(threadName);
  Thread t = new Thread(acceptors[i], threadName);
  t.setPriority(getAcceptorThreadPriority());
  t.setDaemon(getDaemon());
  t.start();
 }
}

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線程進入等待狀態(tài)，直到其他線程釋放,這是一種簡單的通過連接數(shù)量進行流量控制的手段
     //通過實現(xiàn)AQS組件實現(xiàn)（LimitLatch），思路是先初始化同步器的最大限制值，然后每接收一個套接字就將計數(shù)變量累加1，每關閉一個套接字將計數(shù)變量減1
     countUpOrAwaitConnection();
     Socket socket = null;
     try {
      //accept下個socket連接，如果一直沒有連接過來這個方法阻塞
      socket = serverSocketFactory.acceptSocket(serverSocket);
     } catch (IOException ioe) {
      //有異常的話釋放一個連接數(shù)
      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;
  }
 }

<Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
   maxThreads="150" SSLEnabled="true">
 <SSLHostConfig>
  <Certificate certificateKeystoreFile="conf/localhost-rsa.jks"
      type="RSA" />
 </SSLHostConfig>
</Connector>

protected class SocketProcessor implements Runnable {
 //進行Debug調試的時候可以從這個類的run方法開始調試
	@Override
 public void run() { 
 	//對套接字進行處理并輸出響應
  //對連接限流器LimitLatch減一
  //關閉套接字
 }
}