系統(tǒng)之家 - 系統(tǒng)光盤下載網站！

當前位置：系統(tǒng)之家 > 系統(tǒng)教程 > Java四種線程池的使用介紹

線程池是什么？Java四種線程池的使用介紹

時間：2017-09-08 15:59:58 作者：chunhua 來源：系統(tǒng)之家 1. 掃描二維碼隨時看資訊 2. 請使用手機瀏覽器訪問： https://m.xitongzhijia.net/xtjc/20170908/106740.html 手機查看 評論

　　使用線程池的好處有很多，比如節(jié)省系統(tǒng)資源的開銷，節(jié)省創(chuàng)建和銷毀線程的時間等，當我們需要處理的任務較多時，就可以使用線程池，可能還有很多用戶不知道Java線程池如何使用？下面小編給大家分享Java四種線程池的使用方法。

　　線程池介紹：

　　線程池是一種多線程處理形式，處理過程中將任務添加到隊列，然后在創(chuàng)建線程后自動啟動這些任務。線程池線程都是后臺線程。每個線程都使用默認的堆棧大小，以默認的優(yōu)先級運行，并處于多線程單元中。如果某個線程在托管代碼中空閑（如正在等待某個事件），則線程池將插入另一個輔助線程來使所有處理器保持繁忙。如果所有線程池線程都始終保持繁忙，但隊列中包含掛起的工作，則線程池將在一段時間后創(chuàng)建另一個輔助線程但線程的數(shù)目永遠不會超過最大值。超過最大值的線程可以排隊，但他們要等到其他線程完成后才啟動。

　　Java四種線程池的使用：

　　Java通過Executors提供四種線程池，分別為：

　　newCachedThreadPool創(chuàng)建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。

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

　　newScheduledThreadPool 創(chuàng)建一個定長線程池，支持定時及周期性任務執(zhí)行。

　　newSingleThreadExecutor 創(chuàng)建一個單線程化的線程池，它只會用唯一的工作線程來執(zhí)行任務，保證所有任務按照指定順序（FIFO， LIFO， 優(yōu)先級）執(zhí)行。

　�。�1） newCachedThreadPool

　　創(chuàng)建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。示例代碼如下：

  1. 01package test;
  2. 02import java.util.concurrent.ExecutorService;
  3. 03import java.util.concurrent.Executors;
  4. 04public class ThreadPoolExecutorTest {
  5. 05public static void main(String[] args) {
  6. 06ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  7. 07for (int i = 0; i < 10; i++) {
  8. 08final int index = i;
  9. 09try {
  10. 10Thread.sleep(index * 1000);
  11. 11} catch (InterruptedException e) {
  12. 12e.printStackTrace();
  13. 13}
  14. 14cachedThreadPool.execute(new Runnable() {
  15. 15public void run() {
  16. 16System.out.println(index);
  17. 17}
  18. 18});
  19. 19}
  20. 20}
  21. 21}
復制代碼
package test; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolExecutorTest { public static void main(String[] args) { ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { final int index = i; try { Thread.sleep(index * 1000); } catch (InterruptedException e) { e.printStackTrace(); } cachedThreadPool.execute(new Runnable() { public void run() { System.out.println(index); } }); } } }

　　線程池為無限大，當執(zhí)行第二個任務時第一個任務已經完成，會復用執(zhí)行第一個任務的線程，而不用每次新建線程。

　　（2） newFixedThreadPool

　　創(chuàng)建一個定長線程池，可控制線程最大并發(fā)數(shù)，超出的線程會在隊列中等待。示例代碼如下：

  1. 01package test;
  2. 02import java.util.concurrent.ExecutorService;
  3. 03import java.util.concurrent.Executors;
  4. 04public class ThreadPoolExecutorTest {
  5. 05public static void main(String[] args) {
  6. 06ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
  7. 07for (int i = 0; i < 10; i++) {
  8. 08final int index = i;
  9. 09fixedThreadPool.execute(new Runnable() {
  10. 10public void run() {
  11. 11try {
  12. 12System.out.println(index);
  13. 13Thread.sleep(2000);
  14. 14} catch (InterruptedException e) {
  15. 15e.printStackTrace();
  16. 16}
  17. 17}
  18. 18});
  19. 19}
  20. 20}
  21. 21}
復制代碼
package test; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolExecutorTest { public static void main(String[] args) { ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3); for (int i = 0; i < 10; i++) { final int index = i; fixedThreadPool.execute(new Runnable() { public void run() { try { System.out.println(index); Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } }); } } }

　　因為線程池大小為3，每個任務輸出index后sleep 2秒，所以每兩秒打印3個數(shù)字。

　　定長線程池的大小最好根據系統(tǒng)資源進行設置。如Runtime.getRuntime（）.availableProcessors（）

　�。�3） newScheduledThreadPool

　　創(chuàng)建一個定長線程池，支持定時及周期性任務執(zhí)行。延遲執(zhí)行示例代碼如下：

  1. 01package test;
  2. 02import java.util.concurrent.Executors;
  3. 03import java.util.concurrent.ScheduledExecutorService;
  4. 04import java.util.concurrent.TimeUnit;
  5. 05public class ThreadPoolExecutorTest {
  6. 06public static void main(String[] args) {
  7. 07ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  8. 08scheduledThreadPool.schedule(new Runnable() {
  9. 09public void run() {
  10. 10System.out.println("delay 3 seconds");
  11. 11}
  12. 12}, 3, TimeUnit.SECONDS);
  13. 13}
  14. 14}
復制代碼
package test; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class ThreadPoolExecutorTest { public static void main(String[] args) { ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5); scheduledThreadPool.schedule(new Runnable() { public void run() { System.out.println("delay 3 seconds"); } }, 3, TimeUnit.SECONDS); } }

　　表示延遲3秒執(zhí)行。

　　定期執(zhí)行示例代碼如下：

  1. 01package test;
  2. 02import java.util.concurrent.Executors;
  3. 03import java.util.concurrent.ScheduledExecutorService;
  4. 04import java.util.concurrent.TimeUnit;
  5. 05public class ThreadPoolExecutorTest {
  6. 06public static void main(String[] args) {
  7. 07ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  8. 08scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
  9. 09public void run() {
  10. 10System.out.println("delay 1 seconds, and excute every 3 seconds");
  11. 11}
  12. 12}, 1, 3, TimeUnit.SECONDS);
  13. 13}
  14. 14}
復制代碼
package test; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class ThreadPoolExecutorTest { public static void main(String[] args) { ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5); scheduledThreadPool.scheduleAtFixedRate(new Runnable() { public void run() { System.out.println("delay 1 seconds, and excute every 3 seconds"); } }, 1, 3, TimeUnit.SECONDS); } }

　　表示延遲1秒后每3秒執(zhí)行一次。

　�。�4） newSingleThreadExecutor

　　創(chuàng)建一個單線程化的線程池，它只會用唯一的工作線程來執(zhí)行任務，保證所有任務按照指定順序（FIFO， LIFO， 優(yōu)先級）執(zhí)行。示例代碼如下：

  1. 01package test;
  2. 02import java.util.concurrent.ExecutorService;
  3. 03import java.util.concurrent.Executors;
  4. 04public class ThreadPoolExecutorTest {
  5. 05public static void main(String[] args) {
  6. 06ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  7. 07for (int i = 0; i < 10; i++) {
  8. 08final int index = i;
  9. 09singleThreadExecutor.execute(new Runnable() {
  10. 10public void run() {
  11. 11try {
  12. 12System.out.println(index);
  13. 13Thread.sleep(2000);
  14. 14} catch (InterruptedException e) {
  15. 15e.printStackTrace();
  16. 16}
  17. 17}
  18. 18});
  19. 19}
  20. 20}
  21. 21}
復制代碼
package test; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolExecutorTest { public static void main(String[] args) { ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor(); for (int i = 0; i < 10; i++) { final int index = i; singleThreadExecutor.execute(new Runnable() { public void run() { try { System.out.println(index); Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } }); } } }

　　結果依次輸出，相當于順序執(zhí)行各個任務。

　　你可以使用JDK自帶的監(jiān)控工具來監(jiān)控我們創(chuàng)建的線程數(shù)量，運行一個不終止的線程，創(chuàng)建指定量的線程，來觀察：

　　工具目錄：C:\Program Files\Java\jdk1.6.0_06\bin\jconsole.exe

　　運行程序做稍微修改：

  1. 01package test;
  2. 02import java.util.concurrent.ExecutorService;
  3. 03import java.util.concurrent.Executors;
  4. 04public class ThreadPoolExecutorTest {
  5. 05public static void main(String[] args) {
  6. 06ExecutorService singleThreadExecutor = Executors.newCachedThreadPool();
  7. 07for (int i = 0; i < 100; i++) {
  8. 08final int index = i;
  9. 09singleThreadExecutor.execute(new Runnable() {
  10. 10public void run() {
  11. 11try {
  12. 12while(true) {
  13. 13System.out.println(index);
  14. 14Thread.sleep(10 * 1000);
  15. 15}
  16. 16} catch (InterruptedException e) {
  17. 17e.printStackTrace();
  18. 18}
  19. 19}
  20. 20});
  21. 21try {
  22. 22Thread.sleep(500);
  23. 23} catch (InterruptedException e) {
  24. 24e.printStackTrace();
  25. 25}
  26. 26}
  27. 27}
  28. 28}
復制代碼
package test; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolExecutorTest { public static void main(String[] args) { ExecutorService singleThreadExecutor = Executors.newCachedThreadPool(); for (int i = 0; i < 100; i++) { final int index = i; singleThreadExecutor.execute(new Runnable() { public void run() { try { while(true) { System.out.println(index); Thread.sleep(10 * 1000); } } catch (InterruptedException e) { e.printStackTrace(); } } }); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } } } }

　　效果如下：

線程池是什么？Java四種線程池的使用介紹

　　選擇我們運行的程序：

線程池是什么？Java四種線程池的使用介紹

監(jiān)控運行狀態(tài)

　　關于Java四種線程池的使用技巧就給大家分享到這里了，正所謂工欲善其事，必先利其器，我們掌握了訣竅，處理事情才能事倍功半，希望可以幫助到大家。

發(fā)表評論

共0條

沒有更多評論了

評論就這些咯，讓大家也知道你的獨特見解

立即評論

以上留言僅代表用戶個人觀點，不代表系統(tǒng)之家立場

其他版本軟件

    熱門教程

    • 年
    • 月
    • 周

    人氣教程排行

    相關系統(tǒng)推薦

    官方交流群 軟件收錄