一、線程

1、什么是線程

線程(thread) 是操作系統能夠進行運算調度的最小單位。它被包含在進程之中，是進程中的實際 運作單位。一條線程指的是進程中一個單一順序的控制流，一個進程中可以并發多個線程，每條線 程并行執行不同的任務。

2、如何創建線程

2.1、JAVA 中創建線程

/**
 * 繼承Thread類，重寫run方法
 */
classMyThreadextendsThread{
    @Override
    publicvoidrun(){
        System.out.println("myThread..."+Thread.currentThread().getName());
}}

/**
 * 實現Runnable接口，實現run方法 
 */
classMyRunnableimplementsRunnable{
    @Override
    publicvoidrun(){
        System.out.println("MyRunnable..."+Thread.currentThread().getName());
}}

/**
 * 實現Callable接口，指定返回類型，實現call方法
 */
classMyCallableimplementsCallable {
    @Override
    publicStringcall()throwsException{
        return"MyCallable..."+Thread.currentThread().getName();
}}

2.2、測試一下

publicstaticvoidmain(String[] args)throwsException{
    MyThread thread =newMyThread();
    thread.run();//myThread...main
    thread.start();//myThread...Thread-0
    
    MyRunnable myRunnable =newMyRunnable();
    Thread thread1 =newThread(myRunnable);
    myRunnable.run();//MyRunnable...main
    thread1.start();//MyRunnable...Thread-1
    
    MyCallable myCallable =newMyCallable();
    FutureTask futureTask =newFutureTask<>(myCallable);
    Thread thread2 =newThread(futureTask);
    thread2.start();
    System.out.println(myCallable.call());//MyCallable...main
    System.out.println(futureTask.get());//MyCallable...Thread-2

}

2.3、問題

既然我們創建了線程，那為何我們直接調用方法和我們調用 start () 方法的結果不同？new Thread () 是否真實創建了線程？

2.4、問題分析

我們直接調用方法，可以看到是執行的主線程，而調用 start () 方法就是開啟了新線程，那說明 new Thread () 并沒有創建線程，而是在 start () 中創建了線程。 那我們看下 Thread 類 start () 方法:

classThreadimplementsRunnable{//Thread類實現了Runnalbe接口，實現了run()方法 
    
    privateRunnable target;

    publicsynchronizedvoidstart(){
        ...

        boolean started =false;
        try{
            start0();//可以看到，start()方法真實的調用時start0()方法 
            started =true;
        }finally{
            ...     
        } 
    }
    
    privatenativevoidstart0();//start0()是一個native方法，由JVM調用底層操作系統，開啟一個線程，由操作系統過統一調度 

    @Override
    publicvoidrun(){
        if(target !=null){
             target.run();//操作系統在執行新開啟的線程時，回調Runnable接口的run()方法，執行我們預設的線程任務

        } 
     } 
}

2.5、總結

1.JAVA 不能直接創建線程執行任務，而是通過創建 Thread 對象調用操作系統開啟線程，在由操作系 統回調 Runnable 接口的 run () 方法執行任務；

2.實現 Runnable 的方式，將線程實際要執行的回調任務單獨提出來了，實現線程的啟動與回調任務 解耦；

3.實現 Callable 的方式，通過 Future 模式不但將線程的啟動與回調任務解耦，而且可以在執行完成后 獲取到執行的結果；

二、多線程

1、什么是多線程

多線程(multithreading)，是指從軟件或者硬件上實現多個線程并發執行的技術。同一個線程只 能處理完一個任務在處理下一個任務，有時我們需要多個任務同時處理，這時，我們就需要創建多 個線程來同時處理任務。

2、多線程有什么好處

2.1、串行處理

publicstaticvoidmain(String[] args)throwsException{
    System.out.println("start...");
    long start =System.currentTimeMillis();
    for(int i =0; i <5; i++){
        Thread.sleep(2000);//每個任務執行2秒 
        System.out.println("task done...");//處理執行結果
    }
    long end =System.currentTimeMillis();
    System.out.println("end...,time = "+(end - start));
}
//執行結果
start...
task done...
task done...
task done...
task done...
task done... end...,time =10043

2.2、并行處理

publicstaticvoidmain(String[] args)throwsException{
    System.out.println("start...");
    long start =System.currentTimeMillis();
    List list =newArrayList<>();

    for(int i =0; i <5; i++){
        Callable callable =newCallable(){
            @Override
            publicStringcall()throwsException{
                Thread.sleep(2000);//每個任務執行2秒 
                return"task done...";
            }

        };
        FutureTask task =newFutureTask(callable);
        list.add(task);
        newThread(task).start();

    }
    
    list.forEach(future ->{
        try{ 
            System.out.println(future.get());//處理執行結果 } catch (Exception e) {
         } 
    });
    
    long end =System.currentTimeMillis();
    System.out.println("end...,time = "+(end - start));

} 
//執行結果
 start...
 task done...
 task done...
 task done...
 task done...
 task done... end...,time =2005

2.3、總結

1.多線程可以把一個任務拆分為幾個子任務，多個子任務可以并發執行，每一個子任務就是一個線程。

2.多線程是為了同步完成多項任務，不是為了提高運行效率，而是為了提高資源使用效率來提高系統 的效率。

2.4、多線程的問題

上面示例中我們可以看到，如果每來一個任務，我們就創建一個線程，有很多任務的情況下，我們 會創建大量的線程，可能會導致系統資源的耗盡。同時，我們知道線程的執行是需要搶占 CPU 資源 的，那如果有太多的線程，就會導致大量時間用在線程切換的開銷上。 再有，每來一個任務都需要創建一個線程，而創建一個線程需要調用操作系統底層方法，開銷較 大，而線程執行完成后就被回收了。在需要大量線程的時候，創建線程的時間就花費不少了。

三、線程池

1、如何設計一個線程池

由于多線程的開發存在上述的一些問題，那我們是否可以設計一個東西來避免這些問題呢？當然可以！線程池就是為了解決這些問題而生的。那我們該如何設計一個線程池來解決這些問題呢？或者說，一個線程池該具備什么樣的功能？

1.1、線程池基本功能

1.多線程會創建大量的線程耗盡資源，那線程池應該對線程數量有所限制，可以保證不會耗盡系統資 源； 2.每次創建新的線程會增加創建時的開銷，那線程池應該減少線程的創建，盡量復用已創建好的線 程；

1.2、線程池面臨問題

1.我們知道線程在執行完自己的任務后就會被回收，那我們如何復用線程？ 2.我們指定了線程的最大數量，當任務數超出線程數時，我們該如何處理？

1.3、創新源于生活

先假設一個場景：假設我們是一個物流公司的管理人員，要配送的貨物就是我們的任務，貨車就是 我們配送工具，我們當然不能有多少貨物就準備多少貨車。那當顧客源源不斷的將貨物交給我們配 送，我們該如何管理才能讓公司經營的最好呢？ 1.最開始貨物來的時候，我們還沒有貨車，每批要運輸的貨物我們都要購買一輛車來運輸； 2.當貨車運輸完成后，暫時還沒有下一批貨物到達，那貨車就在倉庫停著，等有貨物來了立馬就可以 運輸； 3.當我們有了一定數量的車后，我們認為已經夠用了，那后面就不再買車了，這時要是由新的貨物來 了，我們就會讓貨物先放倉庫，等有車回來在配送； 4.當 618 大促來襲，要配送的貨物太多，車都在路上，倉庫也都放滿了，那怎么辦呢？我們就選擇臨 時租一些車來幫忙配送，提高配送的效率； 5.但是貨物還是太多，我們增加了臨時的貨車，依舊配送不過來，那這時我們就沒辦法了，只能讓發 貨的客戶排隊等候或者干脆不接受了； 6.大促圓滿完成后，累計的貨物已經配送完成了，為了降低成本，我們就將臨時租的車都還了；

1.4、技術源于創新

基于上述場景，物流公司就是我們的線程池、貨物就是我們的線程任務、貨車就是我們的線程。我 們如何設計公司的管理貨車的流程，就應該如何設計線程池管理線程的流程。 1.當任務進來我們還沒有線程時，我們就該創建線程執行任務； 2.當線程任務執行完成后，線程不釋放，等著下一個任務進來后接著執行； 3.當創建的線程數量達到一定量后，新來的任務我們存起來等待空閑線程執行，這就要求線程池有個 存任務的容器； 4.當容器存滿后，我們需要增加一些臨時的線程來提高處理效率； 5.當增加臨時線程后依舊處理不了的任務，那就應該將此任務拒絕； 6.當所有任務執行完成后，就應該將臨時的線程釋放掉，以免增加不必要的開銷；

2、線程池具體分析

上文中，我們講了該如何設計一個線程池，下面我們看看大神是如何設計的；

2.1、 JAVA 中的線程池是如何設計的

2.1.1、 線程池設計

看下線程池中的屬性，了解線程池的設計。

publicclassThreadPoolExecutorextendsAbstractExecutorService{

    //線程池的打包控制狀態,用高3位來表示線程池的運行狀態,低29位來表示線程池中工作線程的數量 
    privatefinalAtomicInteger ctl =newAtomicInteger(ctlOf(RUNNING,0)); 
    
    //值為29,用來表示偏移量
     privatestaticfinalint COUNT_BITS =Integer.SIZE -3; 

    //線程池的最大容量
     privatestaticfinalint CAPACITY =(1<< COUNT_BITS)-1; 

    //線程池的運行狀態，總共有5個狀態，用高3位來表示 
    privatestaticfinalint RUNNING =-1<< COUNT_BITS;//接受新任務并處理阻塞隊列中的任務 

    privatestaticfinalint SHUTDOWN =0<< COUNT_BITS;//不接受新任務但會處理阻塞隊列中的任務  

    privatestaticfinalint STOP =1<< COUNT_BITS;//不會接受新任務，也不會處理阻塞隊列中的任務，并且中斷正在運行的任務

    privatestaticfinalint TIDYING =2<< COUNT_BITS;//所有任務都已終止， 工作線程數量為0，即將要執行terminated()鉤子方法 

    privatestaticfinalint TERMINATED =3<< COUNT_BITS;// terminated()方法已經執行結束

    //任務緩存隊列，用來存放等待執行的任務
    privatefinalBlockingQueue workQueue; 

    //全局鎖，對線程池狀態等屬性修改時需要使用這個鎖
    privatefinalReentrantLock mainLock =newReentrantLock(); 

    //線程池中工作線程的集合，訪問和修改需要持有全局鎖
    privatefinalHashSet workers =newHashSet(); 

    // 終止條件
    privatefinalCondition termination = mainLock.newCondition(); 

    //線程池中曾經出現過的最大線程數 
    privateint largestPoolSize; 
    
    //已完成任務的數量
    privatelong completedTaskCount; 
    
    //線程工廠
    privatevolatileThreadFactory threadFactory; 
    
    //任務拒絕策略
    privatevolatileRejectedExecutionHandler handler; 

    //線程存活時間
    privatevolatilelong keepAliveTime; 

    //是否允許核心線程超時
    privatevolatileboolean allowCoreThreadTimeOut; 

    //核心池大小，若allowCoreThreadTimeOut被設置，核心線程全部空閑超時被回收的情況下會為0 
    privatevolatileint corePoolSize; 

    //最大池大小，不得超過CAPACITY
    privatevolatileint maximumPoolSize; 
    
    //默認的任務拒絕策略
    privatestaticfinalRejectedExecutionHandler defaultHandler =newAbortPolicy();

    //運行權限相關
    privatestaticfinalRuntimePermission shutdownPerm = 
        newRuntimePermission("modifyThread");

    ... 
}

小結一下：以上線程池的設計可以看出，線程池的功能還是很完善的。 1.提供了線程創建、數量及存活時間等的管理； 2.提供了線程池狀態流轉的管理； 3.提供了任務緩存的各種容器； 4.提供了多余任務的處理機制； 5.提供了簡單的統計功能；

2.1.2、線程池構造函數

//構造函數
 publicThreadPoolExecutor(int corePoolSize,//核心線程數 
                           int maximumPoolSize,//最大允許線程數 
                           long keepAliveTime,//線程存活時間 
                           TimeUnit unit,//存活時間單位 
                           BlockingQueue workQueue,//任務緩存隊列
                           ThreadFactory threadFactory,//線程工廠 
                           RejectedExecutionHandler handler){//拒絕策略 
    if(corePoolSize <0||
        maximumPoolSize <=0||
        maximumPoolSize < corePoolSize ||
        keepAliveTime <0)
        thrownewIllegalArgumentException();
        
    if(workQueue ==null|| threadFactory ==null|| handler ==null)
        thrownewNullPointerException();
        
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

小結一下： 1.構造函數告訴了我們可以怎樣去適用線程池，線程池的哪些特性是我們可以控制的；

2.1.3、線程池執行

2.1.3.1、提交任務方法

?public void execute(Runnable command);

?Future submit(Runnable task);

?Future submit(Runnable task, T result);

?Future submit(Callable task);

publicFuture submit(Runnable task){
        if(task ==null)thrownewNullPointerException();
        RunnableFuture ftask =newTaskFor(task,null);
        execute(ftask);
        return ftask;
}

可以看到 submit 方法的底層調用的也是 execute 方法，所以我們這里只分析 execute 方法；

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        
        int c = ctl.get();
        //第一步：創建核心線程
        if (workerCountOf(c) < corePoolSize) {  //worker數量小于corePoolSize
            if (addWorker(command, true))       //創建worker
                return;
            c = ctl.get();
        }
        //第二步：加入緩存隊列
        if (isRunning(c) && workQueue.offer(command)) { //線程池處于RUNNING狀態，將任務加入workQueue任務緩存隊列
            int recheck = ctl.get();    
            if (! isRunning(recheck) && remove(command))    //雙重檢查，若線程池狀態關閉了，移除任務
                reject(command);
            else if (workerCountOf(recheck) == 0)       //線程池狀態正常，但是沒有線程了，創建worker
                addWorker(null, false);
        }
        //第三步：創建臨時線程
        else if (!addWorker(command, false))
            reject(command);
    }

小結一下：execute () 方法主要功能：

1.核心線程數量不足就創建核心線程；

2.核心線程滿了就加入緩存隊列；

3.緩存隊列滿了就增加非核心線程；

4.非核心線程也滿了就拒絕任務；

2.1.3.2、創建線程

privatebooleanaddWorker(Runnable firstTask,boolean core){
        retry:
        for(;;){
            int c = ctl.get();
            int rs =runStateOf(c);

            //等價于：rs>=SHUTDOWN && (rs != SHUTDOWN || firstTask != null || workQueue.isEmpty())
            //線程池已關閉，并且無需執行緩存隊列中的任務，則不創建
            if(rs >= SHUTDOWN &&
                !(rs == SHUTDOWN &&
                   firstTask ==null&&
                   ! workQueue.isEmpty()))
                returnfalse;

            for(;;){
                int wc =workerCountOf(c);
                if(wc >= CAPACITY ||
                    wc >=(core ? corePoolSize : maximumPoolSize))
                    returnfalse;
                if(compareAndIncrementWorkerCount(c))//CAS增加線程數
                    break retry;
                c = ctl.get();// Re-read ctl
                if(runStateOf(c)!= rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        //上面的流程走完，就可以真實開始創建線程了
        boolean workerStarted =false;
        boolean workerAdded =false;
        Worker w =null;
        try{
            w =newWorker(firstTask);//這里創建了線程
            finalThread t = w.thread;
            if(t !=null){
                finalReentrantLock mainLock =this.mainLock;
                mainLock.lock();
                try{
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs =runStateOf(ctl.get());

                    if(rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask ==null)){
                        if(t.isAlive())// precheck that t is startable
                            thrownewIllegalThreadStateException();
                        workers.add(w);//這里將線程加入到線程池中
                        int s = workers.size();
                        if(s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded =true;
                    }
                }finally{
                    mainLock.unlock();
                }
                if(workerAdded){
                    t.start();//添加成功，啟動線程
                    workerStarted =true;
                }
            }
        }finally{
            if(! workerStarted)
                addWorkerFailed(w);//添加線程失敗操作
        }
        return workerStarted;
    }

小結：addWorker () 方法主要功能；

1.增加線程數；

2.創建線程 Worker 實例加入線程池；

3.加入完成開啟線程；

4.啟動失敗則回滾增加流程；

2.1.3.3、工作線程的實現

privatefinalclassWorker//Worker類是ThreadPoolExecutor的內部類
        extendsAbstractQueuedSynchronizer  
        implementsRunnable
    {
        
        finalThread thread;//持有實際線程
        Runnable firstTask;//worker所對應的第一個任務，可能為空
        volatilelong completedTasks;//記錄執行任務數

        Worker(Runnable firstTask){
            setState(-1);// inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread =getThreadFactory().newThread(this);
        }
        
        publicvoidrun(){
            runWorker(this);//當前線程調用ThreadPoolExecutor中的runWorker方法，在這里實現的線程復用
        }

        ...繼承AQS，實現了不可重入鎖...
    }

小結：工作線程 Worker 類主要功能；

1.此類持有一個工作線程，不斷處理拿到的新任務，持有的線程即為可復用的線程；

2.此類可看作一個適配類，在 run () 方法中真實調用 runWorker () 方法不斷獲取新任務，完成線程復用；

2.1.3.4、線程的復用

finalvoidrunWorker(Worker w){//ThreadPoolExecutor中的runWorker方法，在這里實現的線程復用
        Thread wt =Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask =null;
        w.unlock();// allow interrupts
        boolean completedAbruptly =true;//標識線程是否異常終止
        try{
            while(task !=null||(task =getTask())!=null){//這里會不斷從任務隊列獲取任務并執行
                w.lock();
                
                //線程是否需要中斷
                if((runStateAtLeast(ctl.get(), STOP)||    
                     (Thread.interrupted()&&
                      runStateAtLeast(ctl.get(), STOP)))&&
                    !wt.isInterrupted())
                    wt.interrupt();
                try{
                    beforeExecute(wt, task);//執行任務前的Hook方法，可自定義
                    Throwable thrown =null;
                    try{
                        task.run();//執行實際的任務
                    }catch(RuntimeException x){
                        thrown = x;throw x;
                    }catch(Error x){
                        thrown = x;throw x;
                    }catch(Throwable x){
                        thrown = x;thrownewError(x);
                    }finally{
                        afterExecute(task, thrown);//執行任務后的Hook方法，可自定義
                    }
                }finally{
                    task =null;//執行完成后，將當前線程中的任務制空，準備執行下一個任務
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly =false;
        }finally{
            processWorkerExit(w, completedAbruptly);//線程執行完成后的清理工作
        }
    }

小結：runWorker () 方法主要功能；

1.循環從緩存隊列中獲取新的任務，直到沒有任務為止；

2.使用 worker 持有的線程真實執行任務；

3.任務都執行完成后的清理工作；

2.1.3.5、隊列中獲取待執行任務

privateRunnablegetTask(){
        boolean timedOut =false;//標識當前線程是否超時未能獲取到task對象

        for(;;){
            int c = ctl.get();
            int rs =runStateOf(c);

            // Check if queue empty only if necessary.
            if(rs >= SHUTDOWN &&(rs >= STOP || workQueue.isEmpty())){
                decrementWorkerCount();
                returnnull;
            }

            int wc =workerCountOf(c);

            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            if((wc > maximumPoolSize ||(timed && timedOut))
                &&(wc >1|| workQueue.isEmpty())){
                if(compareAndDecrementWorkerCount(c))//若線程存活時間超時，則CAS減去線程數量
                    returnnull;
                continue;
            }

            try{
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)://允許超時回收則阻塞等待
                    workQueue.take();//不允許則直接獲取，沒有就返回null
                if(r !=null)
                    return r;
                timedOut =true;
            }catch(InterruptedException retry){
                timedOut =false;
            }
        }
    }

小結：getTask () 方法主要功能；

1.實際在緩存隊列中獲取待執行的任務；

2.在這里管理線程是否要阻塞等待，控制線程的數量；

2.1.3.6、清理工作

privatevoidprocessWorkerExit(Worker w,boolean completedAbruptly){
        if(completedAbruptly)// If abrupt, then workerCount wasn't adjusted
            decrementWorkerCount();

        finalReentrantLock mainLock =this.mainLock;
        mainLock.lock();
        try{
            completedTaskCount += w.completedTasks;
            workers.remove(w);//移除執行完成的線程
        }finally{
            mainLock.unlock();
        }

        tryTerminate();//每次回收完一個線程后都嘗試終止線程池

        int c = ctl.get();
        if(runStateLessThan(c, STOP)){//到這里說明線程池沒有終止
            if(!completedAbruptly){
                int min = allowCoreThreadTimeOut ?0: corePoolSize;
                if(min ==0&&! workQueue.isEmpty())
                    min =1;
                if(workerCountOf(c)>= min)
                    return;// replacement not needed
            }
            addWorker(null,false);//異常終止線程的話，需要在常見一個線程
        }
    }

小結：processWorkerExit () 方法主要功能；

1.真實完成線程池線程的回收；

2.調用嘗試終止線程池；

3.保證線程池正常運行；

2.1.3.7、嘗試終止線程池

finalvoidtryTerminate(){
        for(;;){
            int c = ctl.get();
            
            //若線程池正在執行、線程池已終止、線程池還需要執行緩存隊列中的任務時，返回
            if(isRunning(c)||
                runStateAtLeast(c, TIDYING)||
                (runStateOf(c)== SHUTDOWN &&! workQueue.isEmpty()))
                return;
                
            //執行到這里，線程池為SHUTDOWN且無待執行任務 或 STOP 狀態
            if(workerCountOf(c)!=0){
                interruptIdleWorkers(ONLY_ONE);//只中斷一個線程
                return;
            }

            //執行到這里，線程池已經沒有可用線程了，可以終止了
            finalReentrantLock mainLock =this.mainLock;
            mainLock.lock();
            try{
                if(ctl.compareAndSet(c,ctlOf(TIDYING,0))){//CAS設置線程池終止
                    try{
                        terminated();//執行鉤子方法
                    }finally{
                        ctl.set(ctlOf(TERMINATED,0));//這里將線程池設為終態
                        termination.signalAll();
                    }
                    return;
                }
            }finally{
                mainLock.unlock();
            }
            // else retry on failed CAS
        }
    }

小結：tryTerminate () 方法主要功能；

1.實際嘗試終止線程池；

2.終止成功則調用鉤子方法，并且將線程池置為終態。

2.2、JAVA 線程池總結

以上通過對 JAVA 線程池的具體分析我們可以看出，雖然流程看似復雜，但其實有很多內容都是狀態重復校驗、線程安全的保證等內容，其主要的功能與我們前面所提出的設計功能一致，只是額外增加了一些擴展，下面我們簡單整理下線程池的功能；

2.2.1、主要功能

1.線程數量及存活時間的管理；

2.待處理任務的存儲功能；

3.線程復用機制功能；

4.任務超量的拒絕功能；

2.2.2、擴展功能

1.簡單的執行結果統計功能；

2.提供線程執行異常處理機制；

3.執行前后處理流程自定義；

4.提供線程創建方式的自定義；

2.2.3、流程總結

以上通過對 JAVA 線程池任務提交流程的分析我們可以看出，線程池執行的簡單流程如下圖所示；

2.3、JAVA 線程池使用

線程池基本使用驗證上述流程：

publicstaticvoidmain(String[] args)throwsException{
        
        //創建線程池
       ThreadPoolExecutor threadPoolExecutor =newThreadPoolExecutor(
               5,10,100,TimeUnit.SECONDS,newArrayBlockingQueue(5));
        
        //加入4個任務，小于核心線程，應該只有4個核心線程，隊列為0
        for(int i =0; i <4; i++){
            threadPoolExecutor.submit(newMyRunnable());
        }
        System.out.println("worker count = "+ threadPoolExecutor.getPoolSize());//worker count = 4
        System.out.println("queue size = "+ threadPoolExecutor.getQueue().size());//queue size = 0
        
        //再加4個任務，超過核心線程，但是沒有超過核心線程 + 緩存隊列容量，應該5個核心線程，隊列為3
        for(int i =0; i <4; i++){
            threadPoolExecutor.submit(newMyRunnable());
        }
        System.out.println("worker count = "+ threadPoolExecutor.getPoolSize());//worker count = 5
        System.out.println("queue size = "+ threadPoolExecutor.getQueue().size());//queue size = 3
        
        //再加4個任務，隊列滿了，應該5個熱核心線程，隊列5個，非核心線程2個
        for(int i =0; i <4; i++){
            threadPoolExecutor.submit(newMyRunnable());
        }
        System.out.println("worker count = "+ threadPoolExecutor.getPoolSize());//worker count = 7
        System.out.println("queue size = "+ threadPoolExecutor.getQueue().size());//queue size = 5
        
        //再加4個任務，核心線程滿了，應該5個熱核心線程，隊列5個，非核心線程5個，最后一個拒絕
        for(int i =0; i <4; i++){
            try{
                threadPoolExecutor.submit(newMyRunnable());
            }catch(Exception e){
                e.printStackTrace();//java.util.concurrent.RejectedExecutionException
            }
        }
        System.out.println("worker count = "+ threadPoolExecutor.getPoolSize());//worker count = 10
        System.out.println("queue size = "+ threadPoolExecutor.getQueue().size());//queue size = 5
        System.out.println(threadPoolExecutor.getTaskCount());//共執行15個任務
        
        //執行完成，休眠15秒，非核心線程釋放，應該5個核心線程，隊列為0
        Thread.sleep(1500);
        System.out.println("worker count = "+ threadPoolExecutor.getPoolSize());//worker count = 5
        System.out.println("queue size = "+ threadPoolExecutor.getQueue().size());//queue size = 0
        
        //關閉線程池
        threadPoolExecutor.shutdown();
    }

審核編輯：劉清