為什么要有線程池?

在實際使用中，服務器在創(chuàng)建和銷毀線程上花費的時間和消耗的系統(tǒng)資源都相當大，所以要盡可能減少創(chuàng)建和銷毀線程的次數(shù)。
由于沒有線程創(chuàng)建和銷毀時的消耗，可以提高系統(tǒng)響應速度
可以對線程進行合理的管理

線程池狀態(tài)

1、RUNNING

狀態(tài)說明：線程池處于RUNNING狀態(tài)時，能夠接收新任務以及對已添加的任務進行處理。

2、SHUTDOWN

狀態(tài)說明：線程池處于SHUTDOWN狀態(tài)時，不接收新任務，但能處理已添加的任務

3、STOP

狀態(tài)說明：線程池處于STOP狀態(tài)時，不接收新任務，不處理已添加的任務，并且會中斷正在處理的任務

4、TIDYING

狀態(tài)說明：當所有的任務已終止，ctl記錄的任務數(shù)為0，線程池的狀態(tài)會變?yōu)門IDYING狀態(tài)；當線程池的狀態(tài)變?yōu)門IDYING狀態(tài)時，會調用鉤子函數(shù)terminated(),該方法在ThreadPoolExecutor中是空的，若用戶想在線程池變?yōu)門IDYING時進行相應的處理，就需要重載terminated()函數(shù)實現(xiàn)。
當線程池為STOP時，線程池中執(zhí)行的任務為空時，就會又STOP->TIDYING

5、TERMINATED

狀態(tài)說明：線程池徹底終止，就會變成TERMINATED狀態(tài)

ThreadPoolExecutor核心參數(shù)

corePoolSize

corePoolSize – the number of threads to keep in the pool, even if they are idle, unless allowCoreThreadTimeOut is set

池中持有的線程數(shù)，即使它們處于空閑狀態(tài)，除非設置了allowCoreThreadTimeOut

線程池中的核心線程數(shù)，當提交一個任務時，線程池創(chuàng)建一個新線程執(zhí)行任務，直到當前線程數(shù)等于corePoolSize, 即使有其他空閑線程能夠執(zhí)行新來的任務, 也會繼續(xù)創(chuàng)建線程； 

如果執(zhí)行了線程池的prestartAllCoreThreads()方法，線程池會提前創(chuàng)建并啟動所有核心線程。

案例：

核心線程數(shù)和最大線程數(shù)為1，使用一個不存儲元素的阻塞隊列。

public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 0,
                TimeUnit.SECONDS,
                new SynchronousQueue<>(),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
 
        for (int i = 0; i < 2; i++) {
            executor.execute(()->{
                System.out.println(Thread.currentThread().getName());
            });
            Thread.sleep(1000);
        }
    }

輸出 ：

pool-1-thread-1
pool-1-thread-1

maximumPoolSize

maximumPoolSize – the maximum number of threads to allow in the pool

池中允許存在的最大線程數(shù)

 案例：

核心線程數(shù)是1，最大線程數(shù)為3，使用一個不存儲元素的阻塞隊列。（注意結合workQueue參數(shù)食用~）

public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 3, 0,
                TimeUnit.SECONDS,
                new SynchronousQueue<>(),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
 
        for (int i = 0; i < 3; i++) {
            executor.execute(()->{
                System.out.println(Thread.currentThread().getName());
            });
        }
    }

輸出：

pool-1-thread-1
pool-1-thread-3
pool-1-thread-2 

keepAliveTime

keepAliveTime – when the number of threads is greater than the core, this is the maximum time that excess idle threads will wait for new tasks before terminating. 

當線程數(shù)大于核心時，這是多余空閑線程在終止前等待新任務的最長時間。

線程空閑時的存活時間，即當線程沒有任務執(zhí)行時，該線程繼續(xù)存活的時間；默認情況下，該參數(shù)只在線程數(shù)大于corePoolSize時才有用, 超過這個時間的空閑線程將被終止；

unit

unit – the time unit for the keepAliveTime argument

keepAliveTime參數(shù)的單位

workQueue

workQueue – the queue to use for holding tasks before they are executed. This queue will hold only the Runnable tasks submitted by the execute method. 

用來放置沒有執(zhí)行的任務，此隊列將僅保存execute方法提交的可運行任務。

用來保存等待被執(zhí)行的任務的阻塞隊列。

如果當前線程數(shù)為corePoolSize，繼續(xù)提交的任務被保存到阻塞隊列中，等待被執(zhí)行；

如果當前阻塞隊列滿了，且繼續(xù)提交任務，則創(chuàng)建新的線程執(zhí)行任務，前提是當前線程數(shù)小于maximumPoolSize；當阻塞隊列是無界隊列, 則maximumPoolSize則不起作用, 因為無法提交至核心線程池的線程會一直持續(xù)地放入workQueue。

JDK提供以下隊列：

• ArrayBlockingQueue: 基于數(shù)組結構的有界阻塞隊列，按FIFO排序任務；(常用)
• LinkedBlockingQueue: 基于鏈表結構的阻塞隊列，按FIFO排序任務，吞吐量通常要高于ArrayBlockingQueue；(常用)
• SynchronousQueue: 一個不存儲元素的阻塞隊列，每個插入操作必須等到另一個線程調用移除操作，否則插入操作一直處于阻塞狀態(tài)，吞吐量通常要高于LinkedBlockingQueue；(常用)
• PriorityBlockingQueue: 具有優(yōu)先級的無界阻塞隊列；
• DelayQueue：一個使用優(yōu)先級隊列實現(xiàn)的無界阻塞隊列。
• LinkedTransferQueue：一個由鏈表結構組成的無界阻塞隊列。
• LinkedBlockingDeque：一個由鏈表結構組成的雙向阻塞隊列。

 案例：

核心線程數(shù)是1，最大線程數(shù)為3，使用一個容量為1的隊列。

public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 3, 0,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(1),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
 
        for (int i = 0; i < 3; i++) {
            executor.execute(()->{
                System.out.println(Thread.currentThread().getName());
            });
        }
    }

 輸出：

pool-1-thread-2
pool-1-thread-1
pool-1-thread-2

threadFactory

threadFactory – the factory to use when the executor creates a new thread

創(chuàng)建執(zhí)行器創(chuàng)建線程的工廠

通過自定義的線程工廠可以給每個新建的線程設置一個具有識別度的線程名。默認為DefaultThreadFactory。

案例：

給線程起名字。我是用spring里的類。如不想引入過多依賴，可以自己仿照Executors.defaultThreadFactory()的代碼寫一個類更改namePrefix即可。

public static void main(String[] args){
        CustomizableThreadFactory customizableThreadFactory = new CustomizableThreadFactory("mine-");//import org.springframework.scheduling.concurrent.CustomizableThreadFactory;
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 0,
                TimeUnit.SECONDS,
                new SynchronousQueue<>(),
                customizableThreadFactory,
                new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 1; i++) {
            executor.execute(()->{
                System.out.println(Thread.currentThread().getName());
            });
        }
    }

 輸出：

mine-1

handler

handler – the handler to use when execution is blocked because the thread bounds and queue capacities are reached

達到線程邊界和隊列容量而阻止執(zhí)行時使用的處理程序

線程池的飽和策略，當阻塞隊列滿了，且沒有空閑的工作線程，如果繼續(xù)提交任務，必須采取一種策略處理該任務，

線程池提供了4種策略:

AbortPolicy: 直接拋出異常，默認策略；

CallerRunsPolicy: 用調用者所在的線程來執(zhí)行任務；

DiscardOldestPolicy: 丟棄阻塞隊列中靠最前的任務，并執(zhí)行當前任務；

DiscardPolicy: 直接丟棄任務；

案例：

以 CallerRunsPolicy為案例。核心和最大線程數(shù)為1。

public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 0,
                TimeUnit.SECONDS,
                new SynchronousQueue<>(),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
 
        for (int i = 0; i < 3; i++) {
            executor.execute(()->{
                System.out.println(Thread.currentThread().getName());
            });
        }
    }

輸出：

main
main
pool-1-thread-1 

關閉線程池的方式

shutdown：

• 修改線程池狀態(tài)為SHUTDOWN
• 不再接收新提交的任務
• 中斷線程池中空閑的線程
• 第3步只是中斷了空閑的線程，但正在執(zhí)行的任務以及線程池任務隊列中的任務會繼續(xù)執(zhí)行完畢

shutdownNow：

• 修改線程池狀態(tài)為STOP
• 不再接收任務提交
• 嘗試中斷線程池中所有的線程（包括正在執(zhí)行的線程）
• 返回正在等待執(zhí)行的任務列表 List<Runnable>

為什么不推薦使用Executors去創(chuàng)建線程池

newFixedThreadPool和newSingleThreadExecutor: 阻塞隊列為無界隊列，主要問題是堆積的請求處理隊列可能會耗費非常大的內存，甚至OOM。newCachedThreadPool和newScheduledThreadPool: 線程數(shù)最大數(shù)是Integer.MAX_VALUE，可能會創(chuàng)建數(shù)量非常多的線程，甚至OOM。

到此這篇關于Java ThreadPoolExecutor線程池有關介紹的文章就介紹到這了,更多相關Java ThreadPoolExecutor 內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論