欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

很多人竟然不知道Java線程池的創(chuàng)建方式有7種

 更新時間:2021年07月30日 08:56:18   作者:麒麟改bug  
本文主要介紹了很多人竟然不知道Java線程池的創(chuàng)建方式有7種,文中通過示例代碼介紹的非常詳細,具有一定的參考價值,感興趣的小伙伴們可以參考一下

前言

根據(jù)摩爾定律所說:集成電路上可容納的晶體管數(shù)量每 18 個月翻一番,因此 CPU 上的晶體管數(shù)量會越來越多。

但隨著時間的推移,集成電路上可容納的晶體管數(shù)量已趨向飽和,摩爾定律也漸漸失效,因此多核 CPU 逐漸變?yōu)橹髁?,與之相對應的多線程編程也開始變得普及和流行起來,這當然也是很久之前的事了,對于現(xiàn)在而言多線程編程已經(jīng)成為程序員必備的職業(yè)技能了,那接下來我們就來盤一盤“線程池”這個多線程編程中最重要的話題。

什么是線程池?

線程池(ThreadPool)是一種基于池化思想管理和使用線程的機制。它是將多個線程預先存儲在一個“池子”內(nèi),當有任務出現(xiàn)時可以避免重新創(chuàng)建和銷毀線程所帶來性能開銷,只需要從“池子”內(nèi)取出相應的線程執(zhí)行對應的任務即可。

池化思想在計算機的應用也比較廣泛,比如以下這些:

  • 內(nèi)存池(Memory Pooling):預先申請內(nèi)存,提升申請內(nèi)存速度,減少內(nèi)存碎片。
  • 連接池(Connection Pooling):預先申請數(shù)據(jù)庫連接,提升申請連接的速度,降低系統(tǒng)的開銷。
  • 實例池(Object Pooling):循環(huán)使用對象,減少資源在初始化和釋放時的昂貴損耗。

線程池的優(yōu)勢主要體現(xiàn)在以下 4 點:

  • 降低資源消耗:通過池化技術重復利用已創(chuàng)建的線程,降低線程創(chuàng)建和銷毀造成的損耗。
  • 提高響應速度:任務到達時,無需等待線程創(chuàng)建即可立即執(zhí)行。
  • 提高線程的可管理性:線程是稀缺資源,如果無限制創(chuàng)建,不僅會消耗系統(tǒng)資源,還會因為線程的不合理分布導致資源調(diào)度失衡,降低系統(tǒng)的穩(wěn)定性。使用線程池可以進行統(tǒng)一的分配、調(diào)優(yōu)和監(jiān)控。
  • 提供更多更強大的功能:線程池具備可拓展性,允許開發(fā)人員向其中增加更多的功能。比如延時定時線程池ScheduledThreadPoolExecutor,就允許任務延期執(zhí)行或定期執(zhí)行。

同時阿里巴巴在其《Java開發(fā)手冊》中也強制規(guī)定:線程資源必須通過線程池提供,不允許在應用中自行顯式創(chuàng)建線程。

說明:線程池的好處是減少在創(chuàng)建和銷毀線程上所消耗的時間以及系統(tǒng)資源的開銷,解決資源不足的問題。如果不使用線程池,有可能造成系統(tǒng)創(chuàng)建大量同類線程而導致消耗完內(nèi)存或者“過度切換”的問題。

知道了什么是線程池以及為什要用線程池之后,我們再來看怎么用線程池。

線程池使用

線程池的創(chuàng)建方法總共有 7 種,但總體來說可分為 2 類:

  • 一類是通過 ThreadPoolExecutor 創(chuàng)建的線程池;
  • 另一個類是通過 Executors 創(chuàng)建的線程池。

線程池的創(chuàng)建方式總共包含以下 7 種(其中 6 種是通過 Executors 創(chuàng)建的,1 種是通過ThreadPoolExecutor 創(chuàng)建的):

  • Executors.newFixedThreadPool:創(chuàng)建一個固定大小的線程池,可控制并發(fā)的線程數(shù),超出的線程會在隊列中等待;
  • Executors.newCachedThreadPool:創(chuàng)建一個可緩存的線程池,若線程數(shù)超過處理所需,緩存一段時間后會回收,若線程數(shù)不夠,則新建線程;
  • Executors.newSingleThreadExecutor:創(chuàng)建單個線程數(shù)的線程池,它可以保證先進先出的執(zhí)行順序;
  • Executors.newScheduledThreadPool:創(chuàng)建一個可以執(zhí)行延遲任務的線程池;
  • Executors.newSingleThreadScheduledExecutor:創(chuàng)建一個單線程的可以執(zhí)行延遲任務的線程池;
  • Executors.newWorkStealingPool:創(chuàng)建一個搶占式執(zhí)行的線程池(任務執(zhí)行順序不確定)【JDK 1.8 添加】。
  • ThreadPoolExecutor:最原始的創(chuàng)建線程池的方式,它包含了 7 個參數(shù)可供設置,后面會詳細講。

單線程池的意義從以上代碼可以看出 newSingleThreadExecutor 和 newSingleThreadScheduledExecutor 創(chuàng)建的都是單線程池,那么單線程池的意義是什么呢?答:雖然是單線程池,但提供了工作隊列,生命周期管理,工作線程維護等功能。

那接下來我們來看每種線程池創(chuàng)建的具體使用。

1.FixedThreadPool

創(chuàng)建一個固定大小的線程池,可控制并發(fā)的線程數(shù),超出的線程會在隊列中等待。

使用示例如下:

public static void fixedThreadPool() {
    // 創(chuàng)建 2 個數(shù)據(jù)級的線程池
    ExecutorService threadPool = Executors.newFixedThreadPool(2);

    // 創(chuàng)建任務
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("任務被執(zhí)行,線程:" + Thread.currentThread().getName());
        }
    };

    // 線程池執(zhí)行任務(一次添加 4 個任務)
    // 執(zhí)行任務的方法有兩種:submit 和 execute
    threadPool.submit(runnable);  // 執(zhí)行方式 1:submit
    threadPool.execute(runnable); // 執(zhí)行方式 2:execute
    threadPool.execute(runnable);
    threadPool.execute(runnable);
}

執(zhí)行結果如下:

如果覺得以上方法比較繁瑣,還用更簡單的使用方法,如下代碼所示:

public static void fixedThreadPool() {
    // 創(chuàng)建線程池
    ExecutorService threadPool = Executors.newFixedThreadPool(2);
    // 執(zhí)行任務
    threadPool.execute(() -> {
        System.out.println("任務被執(zhí)行,線程:" + Thread.currentThread().getName());
    });
}

2.CachedThreadPool

創(chuàng)建一個可緩存的線程池,若線程數(shù)超過處理所需,緩存一段時間后會回收,若線程數(shù)不夠,則新建線程。

使用示例如下:

public static void cachedThreadPool() {
    // 創(chuàng)建線程池
    ExecutorService threadPool = Executors.newCachedThreadPool();
    // 執(zhí)行任務
    for (int i = 0; i < 10; i++) {
        threadPool.execute(() -> {
            System.out.println("任務被執(zhí)行,線程:" + Thread.currentThread().getName());
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
            }
        });
    }
}

執(zhí)行結果如下:

從上述結果可以看出,線程池創(chuàng)建了 10 個線程來執(zhí)行相應的任務。

3.SingleThreadExecutor

創(chuàng)建單個線程數(shù)的線程池,它可以保證先進先出的執(zhí)行順序。

使用示例如下:

public static void singleThreadExecutor() {
    // 創(chuàng)建線程池
    ExecutorService threadPool = Executors.newSingleThreadExecutor();
    // 執(zhí)行任務
    for (int i = 0; i < 10; i++) {
        final int index = i;
        threadPool.execute(() -> {
            System.out.println(index + ":任務被執(zhí)行");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
            }
        });
    }
}

執(zhí)行結果如下:

4.ScheduledThreadPool

創(chuàng)建一個可以執(zhí)行延遲任務的線程池。

使用示例如下:

public static void scheduledThreadPool() {
    // 創(chuàng)建線程池
    ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(5);
    // 添加定時執(zhí)行任務(1s 后執(zhí)行)
    System.out.println("添加任務,時間:" + new Date());
    threadPool.schedule(() -> {
        System.out.println("任務被執(zhí)行,時間:" + new Date());
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
        }
    }, 1, TimeUnit.SECONDS);
}

執(zhí)行結果如下:

從上述結果可以看出,任務在 1 秒之后被執(zhí)行了,符合我們的預期。

5.SingleThreadScheduledExecutor

創(chuàng)建一個單線程的可以執(zhí)行延遲任務的線程池。

使用示例如下:

public static void SingleThreadScheduledExecutor() {
    // 創(chuàng)建線程池
    ScheduledExecutorService threadPool = Executors.newSingleThreadScheduledExecutor();
    // 添加定時執(zhí)行任務(2s 后執(zhí)行)
    System.out.println("添加任務,時間:" + new Date());
    threadPool.schedule(() -> {
        System.out.println("任務被執(zhí)行,時間:" + new Date());
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
        }
    }, 2, TimeUnit.SECONDS);
}

執(zhí)行結果如下:

從上述結果可以看出,任務在 2 秒之后被執(zhí)行了,符合我們的預期。

6.newWorkStealingPool

創(chuàng)建一個搶占式執(zhí)行的線程池(任務執(zhí)行順序不確定),注意此方法只有在 JDK 1.8+ 版本中才能使用。

使用示例如下:

public static void workStealingPool() {
    // 創(chuàng)建線程池
    ExecutorService threadPool = Executors.newWorkStealingPool();
    // 執(zhí)行任務
    for (int i = 0; i < 10; i++) {
        final int index = i;
        threadPool.execute(() -> {
            System.out.println(index + " 被執(zhí)行,線程名:" + Thread.currentThread().getName());
        });
    }
    // 確保任務執(zhí)行完成
    while (!threadPool.isTerminated()) {
    }
}

執(zhí)行結果如下:

從上述結果可以看出,任務的執(zhí)行順序是不確定的,因為它是搶占式執(zhí)行的。

7.ThreadPoolExecutor

最原始的創(chuàng)建線程池的方式,它包含了 7 個參數(shù)可供設置。

使用示例如下:

public static void myThreadPoolExecutor() {
    // 創(chuàng)建線程池
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 10, 100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(10));
    // 執(zhí)行任務
    for (int i = 0; i < 10; i++) {
        final int index = i;
        threadPool.execute(() -> {
            System.out.println(index + " 被執(zhí)行,線程名:" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }
}

執(zhí)行結果如下:

ThreadPoolExecutor 參數(shù)介紹

ThreadPoolExecutor 最多可以設置 7 個參數(shù),如下代碼所示:

 public ThreadPoolExecutor(int corePoolSize,
                           int maximumPoolSize,
                           long keepAliveTime,
                           TimeUnit unit,
                           BlockingQueue<Runnable> workQueue,
                           ThreadFactory threadFactory,
                           RejectedExecutionHandler handler) {
     // 省略...
 }

7 個參數(shù)代表的含義如下:

參數(shù) 1:corePoolSize

核心線程數(shù),線程池中始終存活的線程數(shù)。

參數(shù) 2:maximumPoolSize

最大線程數(shù),線程池中允許的最大線程數(shù),當線程池的任務隊列滿了之后可以創(chuàng)建的最大線程數(shù)。

參數(shù) 3:keepAliveTime

最大線程數(shù)可以存活的時間,當線程中沒有任務執(zhí)行時,最大線程就會銷毀一部分,最終保持核心線程數(shù)量的線程。

參數(shù) 4:unit:

單位是和參數(shù) 3 存活時間配合使用的,合在一起用于設定線程的存活時間 ,參數(shù) keepAliveTime 的時間單位有以下 7 種可選:

  • TimeUnit.DAYS:天
  • TimeUnit.HOURS:小時
  • TimeUnit.MINUTES:分
  • TimeUnit.SECONDS:秒
  • TimeUnit.MILLISECONDS:毫秒
  • TimeUnit.MICROSECONDS:微妙
  • TimeUnit.NANOSECONDS:納秒

參數(shù) 5:workQueue

一個阻塞隊列,用來存儲線程池等待執(zhí)行的任務,均為線程安全,它包含以下 7 種類型:

  • ArrayBlockingQueue:一個由數(shù)組結構組成的有界阻塞隊列。
  • LinkedBlockingQueue:一個由鏈表結構組成的有界阻塞隊列。
  • SynchronousQueue:一個不存儲元素的阻塞隊列,即直接提交給線程不保持它們。
  • PriorityBlockingQueue:一個支持優(yōu)先級排序的無界阻塞隊列。
  • DelayQueue:一個使用優(yōu)先級隊列實現(xiàn)的無界阻塞隊列,只有在延遲期滿時才能從中提取元素。
  • LinkedTransferQueue:一個由鏈表結構組成的無界阻塞隊列。與SynchronousQueue類似,還含有非阻塞方法。
  • LinkedBlockingDeque:一個由鏈表結構組成的雙向阻塞隊列。

較常用的是 LinkedBlockingQueue 和 Synchronous,線程池的排隊策略與 BlockingQueue 有關。

參數(shù) 6:threadFactory

線程工廠,主要用來創(chuàng)建線程,默認為正常優(yōu)先級、非守護線程。

參數(shù) 7:handler

拒絕策略,拒絕處理任務時的策略,系統(tǒng)提供了 4 種可選:

  • AbortPolicy:拒絕并拋出異常。
  • CallerRunsPolicy:使用當前調(diào)用的線程來執(zhí)行此任務。
  • DiscardOldestPolicy:拋棄隊列頭部(最舊)的一個任務,并執(zhí)行當前任務。
  • DiscardPolicy:忽略并拋棄當前任務。

默認策略為 AbortPolicy。

線程池的執(zhí)行流程

ThreadPoolExecutor 關鍵節(jié)點的執(zhí)行流程如下:

  • 當線程數(shù)小于核心線程數(shù)時,創(chuàng)建線程。
  • 當線程數(shù)大于等于核心線程數(shù),且任務隊列未滿時,將任務放入任務隊列。
  • 當線程數(shù)大于等于核心線程數(shù),且任務隊列已滿:若線程數(shù)小于最大線程數(shù),創(chuàng)建線程;若線程數(shù)等于最大線程數(shù),拋出異常,拒絕任務。

線程池的執(zhí)行流程如下圖所示:

線程拒絕策略

我們來演示一下 ThreadPoolExecutor 的拒絕策略的觸發(fā),我們使用 DiscardPolicy 的拒絕策略,它會忽略并拋棄當前任務的策略,實現(xiàn)代碼如下:

public static void main(String[] args) {
    // 任務的具體方法
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("當前任務被執(zhí)行,執(zhí)行時間:" + new Date() +
                               " 執(zhí)行線程:" + Thread.currentThread().getName());
            try {
                // 等待 1s
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    // 創(chuàng)建線程,線程的任務隊列的長度為 1
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1,
                                                           100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1),
                                                           new ThreadPoolExecutor.DiscardPolicy());
    // 添加并執(zhí)行 4 個任務
    threadPool.execute(runnable);
    threadPool.execute(runnable);
    threadPool.execute(runnable);
    threadPool.execute(runnable);
}

我們創(chuàng)建了一個核心線程數(shù)和最大線程數(shù)都為 1 的線程池,并且給線程池的任務隊列設置為 1,這樣當我們有 2 個以上的任務時就會觸發(fā)拒絕策略,執(zhí)行的結果如下圖所示:

從上述結果可以看出只有兩個任務被正確執(zhí)行了,其他多余的任務就被舍棄并忽略了。其他拒絕策略的使用類似,這里就不一一贅述了。

自定義拒絕策略

除了 Java 自身提供的 4 種拒絕策略之外,我們也可以自定義拒絕策略,示例代碼如下:

public static void main(String[] args) {
    // 任務的具體方法
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("當前任務被執(zhí)行,執(zhí)行時間:" + new Date() +
                               " 執(zhí)行線程:" + Thread.currentThread().getName());
            try {
                // 等待 1s
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    // 創(chuàng)建線程,線程的任務隊列的長度為 1
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1,
                                                           100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1),
                                                           new RejectedExecutionHandler() {
                                                               @Override
                                                               public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                                                                   // 執(zhí)行自定義拒絕策略的相關操作
                                                                   System.out.println("我是自定義拒絕策略~");
                                                               }
                                                           });
    // 添加并執(zhí)行 4 個任務
    threadPool.execute(runnable);
    threadPool.execute(runnable);
    threadPool.execute(runnable);
    threadPool.execute(runnable);
}

程序的執(zhí)行結果如下:

究竟選用哪種線程池?

經(jīng)過以上的學習我們對整個線程池也有了一定的認識了,那究竟該如何選擇線程池呢?

我們來看下阿里巴巴《Java開發(fā)手冊》給我們的答案:

【強制】線程池不允許使用 Executors 去創(chuàng)建,而是通過 ThreadPoolExecutor 的方式,這樣的處理方式讓寫的同學更加明確線程池的運行規(guī)則,規(guī)避資源耗盡的風險。
說明:Executors 返回的線程池對象的弊端如下:
1) FixedThreadPool 和 SingleThreadPool:允許的請求隊列長度為 Integer.MAX_VALUE,可能會堆積大量的請求,從而導致 OOM。
2)CachedThreadPool:允許的創(chuàng)建線程數(shù)量為 Integer.MAX_VALUE,可能會創(chuàng)建大量的線程,從而導致 OOM。

所以綜上情況所述,我們推薦使用 ThreadPoolExecutor 的方式進行線程池的創(chuàng)建,因為這種創(chuàng)建方式更可控,并且更加明確了線程池的運行規(guī)則,可以規(guī)避一些未知的風險。

到此這篇關于很多人竟然不知道Java線程池的創(chuàng)建方式有7種 的文章就介紹到這了,更多相關Java線程池創(chuàng)建內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家!

相關文章

  • Java java.lang.InstantiationException異常案例詳解

    Java java.lang.InstantiationException異常案例詳解

    這篇文章主要介紹了Java java.lang.InstantiationException異常案例詳解,本篇文章通過簡要的案例,講解了該項技術的了解與使用,以下就是詳細內(nèi)容,需要的朋友可以參考下
    2021-08-08
  • spring boot 1.5.4 集成shiro+cas,實現(xiàn)單點登錄和權限控制

    spring boot 1.5.4 集成shiro+cas,實現(xiàn)單點登錄和權限控制

    這篇文章主要介紹了spring boot 1.5.4 集成shiro+cas,實現(xiàn)單點登錄和權限控制,需要的朋友可以參考下
    2017-06-06
  • 如何利用JConsole觀察分析Java程序的運行并進行排錯調(diào)優(yōu)

    如何利用JConsole觀察分析Java程序的運行并進行排錯調(diào)優(yōu)

    從Java 5開始 引入了 JConsole。JConsole 是一個內(nèi)置 Java 性能分析器,可以從命令行或在 GUI shell 中運行。您可以輕松地使用 JConsole(或者,它更高端的 “近親” VisualVM )來監(jiān)控 Java 應用程序性能和跟蹤 Java 中的代碼
    2015-12-12
  • SpringBoot實現(xiàn)單文件上傳

    SpringBoot實現(xiàn)單文件上傳

    這篇文章主要為大家詳細介紹了SpringBoot實現(xiàn)單文件上傳,文中示例代碼介紹的非常詳細,具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2019-11-11
  • 現(xiàn)代高效的java構建工具gradle的快速入門

    現(xiàn)代高效的java構建工具gradle的快速入門

    和Maven一樣,Gradle只是提供了構建項目的一個框架,真正起作用的是Plugin,本文主要介紹了gradle入門,文中通過示例代碼介紹的非常詳細,感興趣的小伙伴們可以參考一下
    2021-11-11
  • mybatis 返回Integer,Double,String等類型的數(shù)據(jù)操作

    mybatis 返回Integer,Double,String等類型的數(shù)據(jù)操作

    這篇文章主要介紹了mybatis 返回Integer,Double,String等類型的數(shù)據(jù)操作,具有很好的參考價值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2020-11-11
  • SpringCloud Ribbon 負載均衡的實現(xiàn)

    SpringCloud Ribbon 負載均衡的實現(xiàn)

    Ribbon是一個客戶端負載均衡器,它提供了對HTTP和TCP客戶端的行為的大量控制。這篇文章主要介紹了SpringCloud Ribbon 負載均衡的實現(xiàn),感興趣的小伙伴們可以參考一下
    2019-01-01
  • SpringBoot綠葉顯示yml和端口問題及解決方法

    SpringBoot綠葉顯示yml和端口問題及解決方法

    今天是解決報錯的一天,首先在操作Springboot中的時候,有些朋友的yml顯示的不是綠葉的圖標,或者是配置了之后不生效的問題,今天就給大家分享SpringBoot綠葉顯示yml和端口問題,感興趣的朋友一起看看吧
    2023-01-01
  • SpringBoot配置和切換Tomcat流程詳解

    SpringBoot配置和切換Tomcat流程詳解

    這篇文章主要介紹了如何給springboot配置和切換默認的Tomcat容器以及相關的經(jīng)驗技巧,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
    2022-08-08
  • Java利用redis zset實現(xiàn)延時任務詳解

    Java利用redis zset實現(xiàn)延時任務詳解

    zset作為redis的有序集合數(shù)據(jù)結構存在,排序的依據(jù)就是score。本文就將利用zset score這個排序的這個特性,來實現(xiàn)延時任務,感興趣的可以了解一下
    2022-08-08

最新評論