詳解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è)置一定數(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，每關(guān)閉一個套接字將計數(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調(diào)試的時候可以從這個類的run方法開始調(diào)試
	@Override
  public void run() {  
  	//對套接字進行處理并輸出響應(yīng)
    //對連接限流器LimitLatch減一
    //關(guān)閉套接字
  }
}