server:
  tomcat:
    # 當所有可能的請求處理線程都在使用中時，傳入連接請求的最大隊列長度
    accept-count: 100
    # 服務器在任何給定時間接受和處理的最大連接數(shù)。一旦達到限制，操作系統(tǒng)仍然可以接受基于“acceptCount”屬性的連接。
    max-connections: 8192
    threads:
      # 工作線程的最小數(shù)量，初始化時創(chuàng)建的線程數(shù)
      min-spare: 10
      # 工作線程的最大數(shù)量 io密集型建議10倍的cpu數(shù)，cpu密集型建議cpu數(shù)+1，絕大部分應用都是io密集型
      max: 200
    # 連接器在接受連接后等待顯示請求 URI 行的時間。
    connection-timeout: 20000
    # 在關閉連接之前等待另一個 HTTP 請求的時間。如果未設置，則使用 connectionTimeout。設置為 -1 時不會超時。
    keep-alive-timeout: 20000
    # 在連接關閉之前可以進行流水線處理的最大HTTP請求數(shù)量。當設置為0或1時，禁用keep-alive和流水線處理。當設置為-1時，允許無限數(shù)量的流水線處理或keep-alive請求。 
    max-keep-alive-requests: 100

serverSock = ServerSocketChannel.open();
socketProperties.setProperties(serverSock.socket());
InetSocketAddress addr = new InetSocketAddress(getAddress(), getPortWithOffset());
// 這里
serverSock.socket().bind(addr,getAcceptCount());

// 線程的run方法。
public void run() {    
		while (!stopCalled) { 
	   		// 如果我們已達到最大連接數(shù)，等待
        	connectionLimitLatch.countUpOrAwait();
            // 接受來自服務器套接字的下一個傳入連接
            socket = endpoint.serverSocketAccept()
            // socket.close 釋放的時候 調用 connectionLimitLatch.countDown();    

// tomcat 啟動時
public void createExecutor() {
        internalExecutor = true;
    	// 容量為Integer.MAX_VALUE
        TaskQueue taskqueue = new TaskQueue();
        TaskThreadFactory tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
    	// Tomcat擴展的線程池
        executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS,taskqueue, tf);
        taskqueue.setParent( (ThreadPoolExecutor) executor);
}

NioEndpoint.setSocketOptions	
	socketWrapper.setKeepAliveLeft(NioEndpoint.this.getMaxKeepAliveRequests());
Http11Processor.service(SocketWrapperBase<?> socketWrapper)
  keepAlive = true;
  while(!getErrorState().isError() && keepAlive && !isAsync() && upgradeToken == null &&
                sendfileState == SendfileState.DONE && !protocol.isPaused()) {
    // 默認100  
	int maxKeepAliveRequests = protocol.getMaxKeepAliveRequests();
	if (maxKeepAliveRequests == 1) {
    	keepAlive = false;
	} else if (maxKeepAliveRequests > 0 &&
            //    
        	socketWrapper.decrementKeepAlive() <= 0) {
    	keepAlive = false;
	}

 // Check for read timeout
 if ((socketWrapper.interestOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
     long delta = now - socketWrapper.getLastRead();
     long timeout = socketWrapper.getReadTimeout();
     if (timeout > 0 && delta > timeout) {
         readTimeout = true;
     }
 }
 // Check for write timeout
 if (!readTimeout && (socketWrapper.interestOps() & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE) {
     long delta = now - socketWrapper.getLastWrite();
     long timeout = socketWrapper.getWriteTimeout();
     if (timeout > 0 && delta > timeout) {
         writeTimeout = true;
     }
 }

// Read new bytes if needed
if (byteBuffer.position() >= byteBuffer.limit()) {
    if (keptAlive) {
        // 還沒有讀取任何請求數(shù)據(jù)，所以使用保持活動超時
        wrapper.setReadTimeout(keepAliveTimeout);
    }
    if (!fill(false)) {
        // A read is pending, so no longer in initial state
        parsingRequestLinePhase = 1;
        return false;
    }
    // 	至少已收到請求的一個字節(jié) 切換到套接字超時。
     wrapper.setReadTimeout(connectionTimeout);
}

public void run() {
       while (!stopCalled) {
           // 等待下一個請求進來
           socket = endpoint.serverSocketAccept();
            // 注冊socket到Poller，生成PollerEvent事件
           endpoint.setSocketOptions(socket);
           			// 向輪詢器注冊新創(chuàng)建的套接字
                    - poller.register(socketWrapper);
                        - (SynchronizedQueue(128))events.add(new PollerEvent(socketWrapper))    

public void run() {
       while (true) {
               //查詢selector取出所有請求事件
               Iterator<SelectionKey> iterator =
                   keyCount > 0 ? selector.selectedKeys().iterator() : null;
               // 遍歷就緒鍵的集合并調度任何活動事件。
               while (iterator != null && iterator.hasNext()) {
                   SelectionKey sk = iterator.next();
                   iterator.remove();
                   NioSocketWrapper socketWrapper = (NioSocketWrapper) sk.attachment();
                   // 分配給Executor線程池執(zhí)行處理請求key
                   if (socketWrapper != null) {
                       processKey(sk, socketWrapper);
                       - processSocket(socketWrapper, SocketEvent.OPEN_READ/SocketEvent.OPEN_WRITE)
                           - executor.execute((Runnable)new SocketProcessor(socketWrapper,SocketEvent))
                   }
               }

public void createExecutor() {
        internalExecutor = true;
        TaskQueue taskqueue = new TaskQueue();
        TaskThreadFactory tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
    	// tomcat自定義線程池
        executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS,taskqueue, tf);
        taskqueue.setParent( (ThreadPoolExecutor) executor);
    }

// 與 java.util.concurrent.ThreadPoolExecutor 相同，但實現(xiàn)了更高效的getSubmittedCount()方法，用于正確處理工作隊列。
// 如果未指定 RejectedExecutionHandler，將配置一個默認的，并且該處理程序將始終拋出 RejectedExecutionException
public class ThreadPoolExecutor extends java.util.concurrent.ThreadPoolExecutor {
	// 已提交但尚未完成的任務數(shù)。這包括隊列中的任務和已交給工作線程但后者尚未開始執(zhí)行任務的任務。
    // 這個數(shù)字總是大于或等于getActiveCount() 。
    private final AtomicInteger submittedCount = new AtomicInteger(0);
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        if (!(t instanceof StopPooledThreadException)) {
            submittedCount.decrementAndGet();
        }
    @Override
    public void execute(Runnable command){
        // 提交任務的數(shù)量+1
        submittedCount.incrementAndGet();
        try {
            //  線程池內部方法，真正執(zhí)行的方法。就是JDK線程池原生的方法。
            super.execute(command);
        } catch (RejectedExecutionException rx) {
            // 再次把被拒絕的任務放入到隊列中。
            if (super.getQueue() instanceof TaskQueue) {
                final TaskQueue queue = (TaskQueue)super.getQueue();
                try {
                      //強制的將任務放入到阻塞隊列中
                    if (!queue.force(command, timeout, unit)) {
                        //放入失敗，則繼續(xù)拋出異常
                        submittedCount.decrementAndGet();
                        throw new RejectedExecutionException(sm.getString("threadPoolExecutor.queueFull"));
                    }
                } catch (InterruptedException x) {
                     //被中斷也拋出異常
                    submittedCount.decrementAndGet();
                    throw new RejectedExecutionException(x);
                }
            } else {
                 //不是這種隊列，那么當任務滿了之后，直接拋出去。
                submittedCount.decrementAndGet();
                throw rx;
            }
        }
    }

/**
 * 實現(xiàn)Tomcat特有邏輯的自定義隊列
 */
public class TaskQueue extends LinkedBlockingQueue<Runnable> {
    private static final long serialVersionUID = 1L;
    private transient volatile ThreadPoolExecutor parent = null;
    private static final int DEFAULT_FORCED_REMAINING_CAPACITY = -1;
    /**
     * 強制遺留的容量
     */
    private int forcedRemainingCapacity = -1;
    /**
     * 隊列的構建方法
     */
    public TaskQueue() {
    }
    public TaskQueue(int capacity) {
        super(capacity);
    }
    public TaskQueue(Collection<? extends Runnable> c) {
        super(c);
    }
    /**
     * 設置核心變量
     */
    public void setParent(ThreadPoolExecutor parent) {
        this.parent = parent;
    }
    /**
     * put：向阻塞隊列填充元素，當阻塞隊列滿了之后，put時會被阻塞。
     * offer：向阻塞隊列填充元素，當阻塞隊列滿了之后，offer會返回false。
     *
     * @param o 當任務被拒絕后，繼續(xù)強制的放入到線程池中
     * @return 向阻塞隊列塞任務，當阻塞隊列滿了之后，offer會返回false。
     */
    public boolean force(Runnable o) {
        if (parent == null || parent.isShutdown()) {
            throw new RejectedExecutionException("taskQueue.notRunning");
        }
        return super.offer(o);
    }
    /**
     * 帶有阻塞時間的塞任務
     */
    @Deprecated
    public boolean force(Runnable o, long timeout, TimeUnit unit) throws InterruptedException {
        if (parent == null || parent.isShutdown()) {
            throw new RejectedExecutionException("taskQueue.notRunning");
        }
        return super.offer(o, timeout, unit); //forces the item onto the queue, to be used if the task is rejected
    }
    /**
     * 當線程真正不夠用時，優(yōu)先是開啟線程（直至最大線程），其次才是向隊列填充任務。
     *
     * @param runnable 任務
     * @return false 表示向隊列中添加任務失敗，
     */
    @Override
    public boolean offer(Runnable runnable) {
        if (parent == null) {
            return super.offer(runnable);
        }
        //若是達到最大線程數(shù)，進隊列。
        if (parent.getPoolSize() == parent.getMaximumPoolSize()) {
            return super.offer(runnable);
        }
        //當前活躍線程為10個，但是只有8個任務在執(zhí)行，于是，直接進隊列。
        if (parent.getSubmittedCount() < (parent.getPoolSize())) {
            return super.offer(runnable);
        }
        //當前線程數(shù)小于最大線程數(shù)，那么直接返回false，去創(chuàng)建最大線程
        if (parent.getPoolSize() < parent.getMaximumPoolSize()) {
            return false;
        }
        //否則的話，將任務放入到隊列中
        return super.offer(runnable);
    }
    /**
     * 獲取任務
     */
    @Override
    public Runnable poll(long timeout, TimeUnit unit) throws InterruptedException {
        Runnable runnable = super.poll(timeout, unit);
        //取任務超時，會停止當前線程，來避免內存泄露
        if (runnable == null && parent != null) {
            parent.stopCurrentThreadIfNeeded();
        }
        return runnable;
    }
    /**
     * 阻塞式的獲取任務，可能返回null。
     */
    @Override
    public Runnable take() throws InterruptedException {
        //當前線程應當被終止的情況下：
        if (parent != null && parent.currentThreadShouldBeStopped()) {
            long keepAliveTime = parent.getKeepAliveTime(TimeUnit.MILLISECONDS);
            return poll(keepAliveTime, TimeUnit.MILLISECONDS);
        }
        return super.take();
    }
    /**
     * 返回隊列的剩余容量
     */
    @Override
    public int remainingCapacity() {
        if (forcedRemainingCapacity > DEFAULT_FORCED_REMAINING_CAPACITY) {
            return forcedRemainingCapacity;
        }
        return super.remainingCapacity();
    }
    /**
     * 強制設置剩余容量
     */
    public void setForcedRemainingCapacity(int forcedRemainingCapacity) {
        this.forcedRemainingCapacity = forcedRemainingCapacity;
    }
    /**
     * 重置剩余容量
     */
    void resetForcedRemainingCapacity() {
        this.forcedRemainingCapacity = DEFAULT_FORCED_REMAINING_CAPACITY;
    }
}

server:
  port: 8080
  tomcat:
    accept-count: 3
    max-connections: 6
    threads:
      min-spare: 2
      max: 3

ss -nltp
ss -nlt|grep 8080
- Recv-Q表示（acceptCount）全連接隊列目前長度
- Send-Q表示（acceptCount）全連接隊列的容量。

ss -ntp
ss -nt|grep 8080
- Recv-Q表示客戶端有多少個字節(jié)發(fā)送但還沒有被服務端接收
- Send-Q就表示為有多少個字節(jié)未被客戶端接收。