亚洲激情专区-91九色丨porny丨老师-久久久久久久女国产乱让韩-国产精品午夜小视频观看

溫馨提示×

溫馨提示×

您好,登錄后才能下訂單哦!

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

jdk自帶線程池實例詳解

發布時間:2020-09-18 15:01:34 來源:腳本之家 閱讀:141 作者:牛奮lch 欄目:編程語言

二、簡介

多線程技術主要解決處理器單元內多個線程執行的問題,它可以顯著減少處理器單元的閑置時間,增加處理器單元的吞吐能力,但頻繁的創建線程的開銷是很大的,那么如何來減少這部分的開銷了,那么就要考慮使用線程池了。線程池就是一個線程的容器,每次只執行額定數量的線程,線程池就是用來管理這些額定數量的線程。

三、涉及線程池的類結構圖

jdk自帶線程池實例詳解

其中供我們使用的,主要是ThreadPoolExecutor類。

四、如何創建線程池

我們創建線程池一般有以下幾種方法:

1、使用Executors工廠類

Executors主要提供了下面幾種創建線程池的方法:

jdk自帶線程池實例詳解

下面來看下使用示例:

1)newFixedThreadPool(固定大小的線程池)

public class FixedThreadPool { 
  public static void main(String[] args) { 
    ExecutorService pool = Executors.newFixedThreadPool(5);// 創建一個固定大小為5的線程池 
    for (int i = 0; i < 10; i++) { 
      pool.submit(new MyThread()); 
    } 
    pool.shutdown(); 
  } 
} 
public class MyThread extends Thread { 
  @Override 
  public void run() { 
    System.out.println(Thread.currentThread().getName() + "正在執行。。。"); 
  } 
} 

測試結果如下:

pool-1-thread-1正在執行。。。 
pool-1-thread-2正在執行。。。 
pool-1-thread-3正在執行。。。 
pool-1-thread-2正在執行。。。 
pool-1-thread-3正在執行。。。 
pool-1-thread-2正在執行。。。 
pool-1-thread-2正在執行。。。 
pool-1-thread-3正在執行。。。 
pool-1-thread-5正在執行。。。 
pool-1-thread-4正在執行。。。 

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

2)newSingleThreadExecutor(單線程的線程池)

public class SingleThreadPool { 
  public static void main(String[] args) {  
    ExecutorService pool=Executors.newSingleThreadExecutor();//創建一個單線程池  
    for(int i=0;i<100;i++){  
      pool.submit(new MyThread());  
    }  
    pool.shutdown();  
  } 
} 

測試結果如下:

pool-1-thread-1正在執行。。。 
pool-1-thread-1正在執行。。。 
pool-1-thread-1正在執行。。。 
pool-1-thread-1正在執行。。。 
pool-1-thread-1正在執行。。。 
pool-1-thread-1正在執行。。。 
pool-1-thread-1正在執行。。。 
pool-1-thread-1正在執行。。。 
pool-1-thread-1正在執行。。。 
pool-1-thread-1正在執行。。。 

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

3)newScheduledThreadPool

public class ScheduledThreadPool { 
  public static void main(String[] args) {  
    ScheduledExecutorService pool=Executors.newScheduledThreadPool(6);  
    for(int i=0;i<10000;i++){  
      pool.submit(new MyThread());  
    }  
      
    pool.schedule(new MyThread(), 1000, TimeUnit.MILLISECONDS);  
    pool.schedule(new MyThread(), 1000, TimeUnit.MILLISECONDS);  
    pool.shutdown();  
  }  
} 

測試結果如下:

pool-1-thread-1正在執行。。。 
pool-1-thread-6正在執行。。。 
pool-1-thread-5正在執行。。。 
pool-1-thread-4正在執行。。。 
pool-1-thread-2正在執行。。。 
pool-1-thread-3正在執行。。。 
pool-1-thread-4正在執行。。。 
pool-1-thread-5正在執行。。。 
pool-1-thread-6正在執行。。。 
pool-1-thread-1正在執行。。。 
…………此處會延時1S………… 
pool-1-thread-4正在執行。。。 
pool-1-thread-1正在執行。。。 

測試結果的最后兩個線程都是在延時1S之后,才開始執行的。此線程池支持定時以及周期性執行任務的需求

4)newCachedThreadPool(可緩存的線程池)

public class CachedThreadPool { 
  public static void main(String[] args) {  
    ExecutorService pool=Executors.newCachedThreadPool();  
    for(int i=0;i<100;i++){  
      pool.submit(new MyThread());  
    }  
    pool.shutdown();  
  }  
} 

測試結果如下:

pool-1-thread-5正在執行。。。 
pool-1-thread-7正在執行。。。 
pool-1-thread-5正在執行。。。 
pool-1-thread-16正在執行。。。 
pool-1-thread-17正在執行。。。 
pool-1-thread-16正在執行。。。 
pool-1-thread-5正在執行。。。 
pool-1-thread-7正在執行。。。 
pool-1-thread-16正在執行。。。 
pool-1-thread-18正在執行。。。 
pool-1-thread-10正在執行。。。 

可緩存的線程池:如果線程池的大小超過了處理任務所需要的線程,那么就會回收部分空閑(60秒不執行任務)的線程,當任務數增加時,此線程池又可以智能的添加新線程來處理任務。此線程池不會對線程池大小做限制,線程池大小完全依賴于操作系統(或者說JVM)能夠創建的最大線程大小。

官方建議程序員使用較為方便的Executors工廠方法Executors.newCachedThreadPool()(無界線程池,可以進行自動線程回收)、Executors.newFixedThreadPool(int)(固定大小線程池)Executors.newSingleThreadExecutor()(單個后臺線程),這幾種線程池均為大多數使用場景預定義了默認配置。

2、繼承ThreadPoolExecutor類,并復寫父類的構造方法。

在介紹這種方式之前,我們來分析下前面幾個創建線程池的底層代碼是怎樣的?

public class Executors { 
  public static ExecutorService newFixedThreadPool(int nThreads) { 
    return new ThreadPoolExecutor(nThreads, nThreads, 
                   0L, TimeUnit.MILLISECONDS, 
                   new LinkedBlockingQueue<Runnable>()); 
} 
  public static ExecutorService newSingleThreadExecutor() { 
    return new FinalizableDelegatedExecutorService 
      (new ThreadPoolExecutor(1, 1, 
                  0L, TimeUnit.MILLISECONDS, 
                  new LinkedBlockingQueue<Runnable>())); 
  } 
} 

從Executors工廠類的底層代碼可以看出,工廠類提供的創建線程池的方法,其實都是通過構造ThreadPoolExecutor來實現的。ThreadPoolExecutor構造方法代碼如下:

public ThreadPoolExecutor(int corePoolSize, 
               int maximumPoolSize, 
               long keepAliveTime, 
               TimeUnit unit, 
               BlockingQueue<Runnable> workQueue, 
               ThreadFactory threadFactory, 
               RejectedExecutionHandler handler) { 
    if (corePoolSize < 0 || 
      maximumPoolSize <= 0 || 
      maximumPoolSize < corePoolSize || 
      keepAliveTime < 0) 
      throw new IllegalArgumentException(); 
    if (workQueue == null || threadFactory == null || handler == null) 
      throw new NullPointerException(); 
    this.corePoolSize = corePoolSize; 
    this.maximumPoolSize = maximumPoolSize; 
    this.workQueue = workQueue; 
    this.keepAliveTime = unit.toNanos(keepAliveTime); 
    this.threadFactory = threadFactory; 
    this.handler = handler; 
  } 

那么接下來,我們就來談談這個ThreadPoolExecutor構造方法。在這個構造方法中,主要有以下幾個參數:

corePoolSize--池中所保存的線程數,包括空閑線程。

maximumPoolSize--池中允許的最大線程數。

keepAliveTime--當線程數大于corePoolSize時,此為終止空閑線程等待新任務的最長時間。

Unit--keepAliveTime 參數的時間單位。

workQueue--執行前用于保持任務的隊列。此隊列僅保持由 execute方法提交的 Runnable任務。

threadFactory--執行程序創建新線程時使用的工廠。

Handler--由于超出線程范圍和隊列容量而使執行被阻塞時所使用的處理程序。

接下來,咋們來說下這幾個參數之間的關系。當線程池剛創建的時候,線程池里面是沒有任何線程的(注意,并不是線程池一創建,里面就創建了一定數量的線程),當調用execute()方法添加一個任務時,線程池會做如下的判斷:

1)如果當前正在運行的線程數量小于corePoolSize,那么立刻創建一個新的線程,執行這個任務。

2)如果當前正在運行的線程數量大于或等于corePoolSize,那么這個任務將會放入隊列中。

3)如果線程池的隊列已經滿了,但是正在運行的線程數量小于maximumPoolSize,那么還是會創建新的線程,執行這個任務。

4)如果隊列已經滿了,且當前正在運行的線程數量大于或等于maximumPoolSize,那么線程池會根據拒絕執行策略來處理當前的任務。

5)當一個任務執行完后,線程會從隊列中取下一個任務來執行,如果隊列中沒有需要執行的任務,那么這個線程就會處于空閑狀態,如果超過了keepAliveTime存活時間,則這個線程會被線程池回收(注:回收線程是有條件的,如果當前運行的線程數量大于corePoolSize的話,這個線程就會被銷毀,如果不大于corePoolSize,是不會銷毀這個線程的,線程的數量必須保持在corePoolSize數量內).為什么不是線程一空閑就回收,而是需要等到超過keepAliveTime才進行線程的回收了,原因很簡單:因為線程的創建和銷毀消耗很大,更不能頻繁的進行創建和銷毀,當超過keepAliveTime后,發現確實用不到這個線程了,才會進行銷毀。這其中unit表示keepAliveTime的時間單位,unit的定義如下:

public enum TimeUnit { 
  NANOSECONDS { 
    // keepAliveTime以納秒為單位 
  }, 
  MICROSECONDS { 
    // keepAliveTime以微秒為單位 
  }, 
  MILLISECONDS { 
    // keepAliveTime以毫秒為單位 
  }, 
  SECONDS { 
    // keepAliveTime以秒為單位 
  }, 
  MINUTES { 
    // keepAliveTime以分鐘為單位 
  }, 
  HOURS { 
    // keepAliveTime以小時為單位 
  }, 
  DAYS { 
    // keepAliveTime以天為單位 
  }; 

下面從源碼來分析一下,對于上面的幾種情況,主要涉及到的源碼有以下幾塊:

private boolean addIfUnderCorePoolSize(Runnable firstTask) { 
    Thread t = null; 
    final ReentrantLock mainLock = this.mainLock; 
    mainLock.lock(); 
    try { 
      if (poolSize < corePoolSize && runState == RUNNING) 
        t = addThread(firstTask); 
    } finally { 
      mainLock.unlock(); 
    } 
    if (t == null) 
      return false; 
    t.start(); 
    return true; 
} 

其實,這段代碼很簡單,主要描述的就是,如果當前的線程池小于corePoolSize的時候,是直接新建一個線程來處理任務。 

private boolean addIfUnderMaximumPoolSize(Runnable firstTask) { 
    Thread t = null; 
    final ReentrantLock mainLock = this.mainLock; 
    mainLock.lock(); 
    try { 
      if (poolSize < maximumPoolSize && runState == RUNNING) 
        t = addThread(firstTask); 
    } finally { 
      mainLock.unlock(); 
    } 
    if (t == null) 
      return false; 
    t.start(); 
    return true; 
} 

上面這段代碼描述的是,如果當前線程池的數量小于maximumPoolSize的時候,也會創建一個線程,來執行任務 

五、線程池的隊列

線程池的隊列,總的來說有3種:

直接提交:工作隊列的默認選項是 SynchronousQueue,它將任務直接提交給線程而不保持它們。在此,如果不存在可用于立即運行任務的線程,則試圖把任務加入隊列將失敗,因此會構造一個新的線程。此策略可以避免在處理可能具有內部依賴性的請求集時出現鎖。直接提交通常要求無界 maximumPoolSizes 以避免拒絕新提交的任務。當命令以超過隊列所能處理的平均數連續到達時,此策略允許無界線程具有增長的可能性。

無界隊列:使用無界隊列(例如,不具有預定義容量的 LinkedBlockingQueue)將導致在所有 corePoolSize 線程都忙時新任務在隊列中等待。這樣,創建的線程就不會超過 corePoolSize。(因此,maximumPoolSize的值也就無效了。)當每個任務完全獨立于其他任務,即任務執行互不影響時,適合于使用無界隊列;例如,在 Web頁服務器中。這種排隊可用于處理瞬態突發請求,當命令以超過隊列所能處理的平均數連續到達時,此策略允許無界線程具有增長的可能性。

有界隊列:當使用有限的 maximumPoolSizes時,有界隊列(如 ArrayBlockingQueue)有助于防止資源耗盡,但是可能較難調整和控制。隊列大小和最大池大小可能需要相互折衷:使用大型隊列和小型池可以最大限度地降低 CPU 使用率、操作系統資源和上下文切換開銷,但是可能導致人工降低吞吐量。如果任務頻繁阻塞(例如,如果它們是 I/O邊界),則系統可能為超過您許可的更多線程安排時間。使用小型隊列通常要求較大的池大小,CPU使用率較高,但是可能遇到不可接受的調度開銷,這樣也會降低吞吐量。

下面就來說下線程池的隊列,類結構圖如下:

jdk自帶線程池實例詳解

1)SynchronousQueue

該隊列對應的就是上面所說的直接提交,首先SynchronousQueue是無界的,也就是說他存數任務的能力是沒有限制的,但是由于該Queue本身的特性,在某次添加元素后必須等待其他線程取走后才能繼續添加。

2)LinkedBlockingQueue

該隊列對應的就是上面的無界隊列。

3)ArrayBlockingQueue

該隊列對應的就是上面的有界隊列。ArrayBlockingQueue有以下3中構造方法:

public ArrayBlockingQueue(int capacity) { 
    this(capacity, false); 
  } 
  public ArrayBlockingQueue(int capacity, boolean fair) { 
    if (capacity <= 0) 
      throw new IllegalArgumentException(); 
    this.items = (E[]) new Object[capacity]; 
    lock = new ReentrantLock(fair); 
    notEmpty = lock.newCondition(); 
    notFull = lock.newCondition(); 
} 
  public ArrayBlockingQueue(int capacity, boolean fair, 
               Collection<? extends E> c) { 
    this(capacity, fair); 
    if (capacity < c.size()) 
      throw new IllegalArgumentException(); 
    for (Iterator<? extends E> it = c.iterator(); it.hasNext();) 
      add(it.next()); 
  } 

下面我們重點來說下這個fair,fair表示隊列訪問線程的競爭策略,當為true的時候,任務插入隊列遵從FIFO的規則,如果為false,則可以“插隊”。舉個例子,假如現在有很多任務在排隊,這個時候正好一個線程執行完了任務,同時又新來了一個任務,如果為false的話,這個任務不用在隊列中排隊,可以直接插隊,然后執行。如下圖所示:

jdk自帶線程池實例詳解

六、線程池的拒絕執行策略

當線程的數量達到最大值時,這個時候,任務還在不斷的來,這個時候,就只好拒絕接受任務了。

ThreadPoolExecutor 允許自定義當添加任務失敗后的執行策略。你可以調用線程池的 setRejectedExecutionHandler() 方法,用自定義的RejectedExecutionHandler 對象替換現有的策略,ThreadPoolExecutor提供的默認的處理策略是直接丟棄,同時拋異常信息,ThreadPoolExecutor 提供 4 個現有的策略,分別是:
ThreadPoolExecutor.AbortPolicy:表示拒絕任務并拋出異常,源碼如下:

public static class AbortPolicy implements RejectedExecutionHandler { 
    /** 
     * Creates an <tt>AbortPolicy</tt>. 
     */ 
    public AbortPolicy() { } 
    /** 
     * Always throws RejectedExecutionException. 
     * @param r the runnable task requested to be executed 
     * @param e the executor attempting to execute this task 
     * @throws RejectedExecutionException always. 
     */ 
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { 
      throw new RejectedExecutionException(); //拋異常 
    } 
  } 

 ThreadPoolExecutor.DiscardPolicy:表示拒絕任務但不做任何動作,源碼如下:

public static class DiscardPolicy implements RejectedExecutionHandler { 
    /** 
     * Creates a <tt>DiscardPolicy</tt>. 
     */ 
    public DiscardPolicy() { } 
    /** 
     * Does nothing, which has the effect of discarding task r. 
     * @param r the runnable task requested to be executed 
     * @param e the executor attempting to execute this task 
     */ 
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { 
    } // 直接拒絕,但不做任何操作 
  } 

ThreadPoolExecutor.CallerRunsPolicy:表示拒絕任務,并在調用者的線程中直接執行該任務,源碼如下:

public static class CallerRunsPolicy implements RejectedExecutionHandler { 
    /** 
     * Creates a <tt>CallerRunsPolicy</tt>. 
     */ 
    public CallerRunsPolicy() { } 
    /** 
     * Executes task r in the caller's thread, unless the executor 
     * has been shut down, in which case the task is discarded. 
     * @param r the runnable task requested to be executed 
     * @param e the executor attempting to execute this task 
     */ 
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { 
      if (!e.isShutdown()) { 
        r.run(); // 直接執行任務 
      } 
    } 
  } 

 ThreadPoolExecutor.DiscardOldestPolicy:表示先丟棄任務隊列中的第一個任務,然后把這個任務加進隊列。源碼如下:

public static class DiscardOldestPolicy implements RejectedExecutionHandler { 
    /** 
     * Creates a <tt>DiscardOldestPolicy</tt> for the given executor. 
     */ 
    public DiscardOldestPolicy() { } 
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { 
      if (!e.isShutdown()) { 
        e.getQueue().poll(); // 丟棄隊列中的第一個任務 
        e.execute(r); // 執行新任務 
      } 
    } 
} 

當任務源源不斷到來的時候,會從Queue中poll一個任務出來,然后執行新的任務 

總結

以上所述是小編給大家介紹的jdk自帶線程池詳解,希望對大家有所幫助,如果大家有任何疑問請給我留言,小編會及時回復大家的。在此也非常感謝大家對億速云網站的支持!

向AI問一下細節

免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。

AI

崇明县| 定襄县| 肃南| 武冈市| 临朐县| 建阳市| 彭泽县| 临城县| 绵阳市| 天祝| 罗平县| 南和县| 宜兰市| 沧源| 民丰县| 图片| 临漳县| 安国市| 高清| 汾西县| 深州市| 甘孜| 台江县| 礼泉县| 永顺县| 体育| 萨迦县| 富民县| 明溪县| 迭部县| 遂平县| 苍南县| 玉门市| 樟树市| 额敏县| 广州市| 尚义县| 扬州市| 泸定县| 乐都县| 交口县|