具體如下圖

使用執行緒池好處：
1、在高併發的時候，降低峰值，避免阻塞，影響效能，最大案例就是京東某年 某次活動的時候，伺服器直接罷工。增加伺服器和延遲峰值，延遲某些操作即能延遲的 就延遲操作，這兩個方面可以緩解高併發問題。
2、統一化管理的優點他都有，就是減少資源的建立 銷燬時間，資源的複用

一、Executor

基本的介面類，可以執行runable的實現類。把執行緒加入佇列的過程。

public interface Executor {
     void execute(Runnable command);
}

案例：

public class TaskExecutionWebServer {
//設定執行緒數量的界限
    private static final int MTHREDS = 100;
    //建立一個固定長度的執行緒池。每次提交一個就建立一個，直至最大執行緒數量。
    private static final Executor exec = Executors.newFixedThreadPool(MTHREDS);

    public
 
 static void main(String[] args) throws IOException {
        ServerSocket socket = new ServerSocket(8080);
        while (true) {
            final Socket connection = socket.accept();
            Runnable taskRunnable = new Runnable() {
                @Override
                public void run() {
                    // handleRequest(connection);
 

                }
            };
            //新增到執行緒池，執行緒佇列，等待執行。
            exec.execute(taskRunnable);
        }
    }

}

二、ExecutorService

繼承Executor 介面，擴充套件了Future等，方法。可以是執行緒單向執行即建立->呼叫->執行->結束。使用狀態不可逆行。 可以新增callable執行緒方法。

public interface ExecutorService extends Executor {
     void shutdown();
     List<Runnable> shutdownNow();
     boolean isShutdown();
     boolean isTerminated();
     boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
     .....
}

三 Executors

工具類：，對執行緒池的實現輔助。提供執行緒池的建立。

    public static ExecutorService newFixedThreadPool(int nThreads) 
    public static ExecutorService newSingleThreadExecutor() 
    public static ExecutorService newCachedThreadPool() 
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

四、ThreadPoolExecutor

執行緒池類，對執行緒池的流程的關鍵類，繼承AbstractExecutorService 類。

public abstract class AbstractExecutorService implements ExecutorService ｛

｝

public class ThreadPoolExecutor extends AbstractExecutorService {

}

五、CallBack

/*
 java.util.concurrent.Callable<Object>


A task that returns a result and may throw an exception. Implementors define a single method with no arguments called call. 

The Callable interface is similar to java.lang.Runnable, in that both are designed for classes whose instances are potentially executed by another thread. A Runnable, however, does not return a result and cannot throw a checked exception. 

The Executors class contains utility methods to convert from other common forms to Callable classes.

See Also:
Executor
*/

/**
給的解釋就是相對於runnable + 返回
即獲取執行緒執行的過程。
*/
class CallBackDemo{
    private static final int MTHREDS = 100;
    private static final ExecutorService exec = Executors.newFixedThreadPool(MTHREDS);
    final ArrayList<Object> infoList=new ArrayList<Object>();
    public void test(){
        Callable<Object> tasks=new Callable<Object>() {
            @Override
            public Object call() throws Exception {  
                return null;
            }
        };

        Future<Object> future= exec.submit(tasks);

    }
}