Java線程池應用

jopen 10年前發布 | 13K 次閱讀 Java線程池 Java開發

1.減少了創建和銷毀線程的次數，每個工作線程都可以被重復利用，可執行多個任務。

2.可以根據系統的承受能力，調整線程池中工作線線程的數目，防止因為消耗過多的內存，而把服務器累趴下(每個線程需要大約1MB內存，線程開的越多，消耗的內存也就越大，最后死機)。

Java里面線程池的頂級接口是Executor，但是嚴格意義上講Executor并不是一個線程池，而只是一個執行線程的工具。真正的線程池接口是ExecutorService。

1. newSingleThreadExecutor

創建一個單線程的線程池。這個線程池只有一個線程在工作，也就是相當于單線程串行執行所有任務。如果這個唯一的線程因為異常結束，那么會有一個新的線程來替代它。此線程池保證所有任務的執行順序按照任務的提交順序執行。

2.newFixedThreadPool

創建固定大小的線程池。每次提交一個任務就創建一個線程，直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變，如果某個線程因為執行異常而結束，那么線程池會補充一個新線程。

3. newCachedThreadPool

創建一個可緩存的線程池。如果線程池的大小超過了處理任務所需要的線程，

那么就會回收部分空閑（60秒不執行任務）的線程，當任務數增加時，此線程池又可以智能的添加新線程來處理任務。此線程池不會對線程池大小做限制，線程池大小完全依賴于操作系統（或者說JVM）能夠創建的最大線程大小。

4.newScheduledThreadPool

創建一個大小無限的線程池。此線程池支持定時以及周期性執行任務的需求


下面我用2個實例來說明一下 ，線程池的簡單實用

[java] view plaincopy
  1. import java.util.concurrent.ExecutorService;  
  2. import java.util.concurrent.Executors;  
  3. import java.util.concurrent.TimeUnit;  
  4.   
  5.   
  6. public class ThreadPool {  
  7.      public static void main(String[] args) {  
  8.          //ExecutorService ThreadPool =  Executors.newFixedThreadPool(3);  
  9.          //ExecutorService ThreadPool = Executors.newCachedThreadPool();  
  10.           ExecutorService ThreadPool = Executors.newSingleThreadExecutor();  
  11.          for(int i=0;i<=4;i++){  
  12.              final int task = i;  
  13.          ThreadPool.execute(new Runnable() {  
  14.               
  15.             @Override  
  16.             public void run() {  
  17.                 for(int j=0;j<=10;j++){  
  18.                     try {  
  19.                         Thread.sleep(20);  
  20.                     } catch (InterruptedException e) {  
  21.                         e.printStackTrace();  
  22.                     }  
  23.                     System.out.println(Thread.currentThread().getName() + " is loopping of " + j + " for task of " + task);  
  24.                 }                 
  25.             }  
  26.         });  
  27.        }  
  28.          //ThreadPool.shutdownNow();  
  29.          Executors.newScheduledThreadPool(3).scheduleAtFixedRate(new Runnable() {  
  30.               
  31.             @Override  
  32.             public void run() {  
  33.                 System.out.println("boombing!!");  
  34.                   
  35.             }  
  36.         }, 5, 2, TimeUnit.SECONDS);  
  37.     }  
  38. }  

[java] view plaincopy
  1. publicclass TestScheduledThreadPoolExecutor {  
  2.     publicstaticvoid main(String[] args) {  
  3.         ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);  
  4.         exec.scheduleAtFixedRate(new Runnable() {//每隔一段時間就觸發異常  
  5.                       @Override  
  6.                       publicvoid run() {  
  7.                            //throw new RuntimeException();  
  8.                            System.out.println("================");  
  9.                       }  
  10.                   }, 1000, 5000, TimeUnit.MILLISECONDS);  
  11.         exec.scheduleAtFixedRate(new Runnable() {//每隔一段時間打印系統時間，證明兩者是互不影響的  
  12.                       @Override  
  13.                       publicvoid run() {  
  14.                            System.out.println(System.nanoTime());  
  15.                       }  
  16.                   }, 1000, 2000, TimeUnit.MILLISECONDS);  
  17.     }  
  18. }  
 本文由用戶 jopen 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。
 轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。
 本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！