Java中線程池的作用有哪些

本篇文章給大家分享的是有關Java中線程池的作用有哪些，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

1.簡介

使用線程池可以避免線程的頻繁創建以及銷毀。

JAVA中提供的用于實現線程池的API：

Executor、ExecutorService、AbstractExecutorService、ThreadPoolExecutor、ForkJoinPool都位于java.util.concurrent包下。

*ThreadPoolExecutor、ForkJoinPool為線程池的實現類。

2.Executor

public interface Executor {

  /**
   * 向線程池提交一個任務,交由線程池去執行
   */
  void execute(Runnable command);

}

*該接口聲明了execute(Runnable command)方法，負責向線程池中提交一個任務。

3.ExecutorService接口

public interface ExecutorService extends Executor {

  /**
   * 關閉線程池(等待隊列中的任務被執行完畢)
   */
  void shutdown();

  /**
   * 立刻關閉線程池(不執行隊列中的任務，并嘗試中斷當前執行的任務)
   */
  List<Runnable> shutdownNow();

  /**
   * 判斷線程池是否處于shutdown狀態.
   */
  boolean isShutdown();

  /**
   * 判斷線程池是否處于terminated狀態.
   */
  boolean isTerminated();

  /**
   * 若在指定時間內線程池處于terminated狀態則立即返回true,否則超過時間后仍未為terminated狀態則返回false.
   */
  boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;

  /**
   * 向線程池提交一個任務并返回包含指定類型的Future(根據Callable的泛型)
   */
  <T> Future<T> submit(Callable<T> task);

  /**
   * 向線程池提交一個任務并指定任務執行結果的類型,返回包含指定類型的Future.
   */
  <T> Future<T> submit(Runnable task, T result);

  /**
   * 向線程池提交一個任務并返回未知類型的Future.
   */
  Future<?> submit(Runnable task);

  /**
   * 向線程池提交多個任務并返回指定類型的Future列表.
   */
  <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;

  /**
   * 向線程池提交多個任務并返回指定類型的Future列表,如果在指定時間內沒有執行完畢則直接返回.
   */
  <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;
   
  /**
   * 向線程池提交多個任務,當任意一個任務執行完畢后返回指定類型的Future.
   */
  <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;

  /**
   * 向線程池提交多個任務,在指定時間內,當任意一個任務執行完畢后返回指定類型的Future,若超時則拋出異常.
   */
  <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

public interface Future<V> {

  /**
   * 中斷任務的執行
   */
  boolean cancel(boolean mayInterruptIfRunning);

  /**
   * 判斷任務是否中斷成功
   */
  boolean isCancelled();

  /**
   * 判斷任務是否執行完成
   */
  boolean isDone();
  
  /**
   * 獲取任務的執行結果直到任務執行完畢(阻塞線程)
   */
  V get() throws InterruptedException, ExecutionException;
 
  /**
   * 獲取任務的執行結果,若在指定時間內任務仍然沒有執行完畢則拋出TimeoutException
   */
  V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

*execute()方法不能獲取任務的執行結果，而submit()方法能夠根據返回的Future實例獲取任務的執行結果。

4.ThreadPoolExecutor

corePoolSize：線程池中核心線程的數量。

maximumPoolSize：線程池中最大線程數。

keepAliveTime：線程的空閑時間。

unit：修飾線程空閑時間的單位。

workQueue：任務隊列。

threadFactory：線程工廠，用于創建線程。

handler：當隊列已滿且當前線程數已達到所允許的最大值時的處理策略。

*線程池中的線程包括核心線程以及普通線程，核心線程一旦創建后直到線程池被關閉前都就不會被銷毀，而普通線程會因為到達空閑時間而被銷毀。

構造方法：

public ThreadPoolExecutor(int corePoolSize,
             int maximumPoolSize,
             long keepAliveTime,
             TimeUnit unit,
             BlockingQueue<Runnable> workQueue,
             ThreadFactory threadFactory,
             RejectedExecutionHandler handler)

BlockingQueue的類型 

 BlockingQueue提供了ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等實現類。

1.ArrayBlockingQueue：使用順序表的結構進行存儲，在使用時需要指定其長度，支持公平鎖/非公平鎖進行操作。

2.LinkedBlockingQueue：使用鏈表的結構進行存儲，在使用時不需要指定其長度，隊列的最大長度為Integer.MAX_VALUE。

3.SynchronousQueue：一個不存儲元素的隊列，每一個put操作必須等待take操作，否則不能添加元素，支持公平鎖和非公平鎖。

 *這些實現類在進行入隊和出隊操作時都會進行加鎖，以保證在多線程并發訪問時數據的安全性。

隊列已滿且線程數已達到所允許的最大值時的處理策略

RejectedExecutionHandler提供了AbortPolicy、DiscardPolicy、DiscardOlderstPolicy、CallerRunsPolicy四個策略，這四個策略都是ThreadPoolExecutor的靜態內部類。

1.AbortPolicy：放棄任務并拋出RejectedExecutionException異常。

2.DiscardPolicy：放棄任務但不拋出異常。

3.DiscardOlderstPolicy： 放棄隊頭中的任務，然后重新嘗試執行新任務。

4.CallerRunsPolicy： 由調用線程來處理該任務。

線程池的狀態

private static final int RUNNING  = -1；
private static final int SHUTDOWN  = 0； 
private static final int STOP    = 1；
private static final int TIDYING  = 2； 
private static final int TERMINATED = 3；

1.RUNING：線程池處于運行狀態，此時可以接受新的任務請求，并且執行隊列中的任務。

2.SHUTDOWN：線程池處于關閉狀態，此時不接受新的任務請求，但會繼續執行隊列中的任務。

3.STOP：線程池處于禁用狀態，此時不接受新的任務請求，并且不會執行隊列中的任務。

4.TIDYING：線程池處于整理狀態，此時沒有正在執行的任務。

5.TERMINATED ：線程池處于終止狀態。

線程池狀態的變化過程

1.當線程池創建后處于RUNNING狀態。

2.1 若此時調用了shutdown()方法，那么線程池將處于SHUTDOWN狀態，不接受新的任務請求，但會繼續執行隊列中的任務，當隊列中的任務為空且沒有正在執行的任務時，線程池的狀態為TIDYING。

2.2 若此時調用了shutdownNow()方法，那么線程池將處于STOP狀態，不接受新的任務請求并且不執行隊列中的任務，此時線程池的狀態為TIDYING。

3.當線程池的狀態為TIDYING時，當terminated()方法處理完畢后，線程池的狀態為TRRMINATED。

任務的執行流程

1.當調用了execute()或者submit()方法向線程池提交一個任務后，首先判斷當前線程池中的線程個數是否大于核心線程數。

2.如果當前線程池的線程個數小于核心線程數，則創建一個核心線程來處理任務。

3.如果當前線程池的線程個數大于核心線程數，則將任務放入到隊列中，如果放入隊列成功，那么該任務將等待被空閑的線程處理，如果放入隊列失敗(隊滿)，則判斷當前線程池中的線程個數是否達到所允許的最大值，若未達到則創建一個普通線程去處理任務，否則根據預定義的處理策略去進行處理。

5.Executors工具類

JAVA中提供了Executors工具類，用于直接創建Executor。

CacheThreadPool

public static ExecutorService newCachedThreadPool() {
  return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());
}

CacheThreadPool創建的都是普通線程(其核心線程數為0)、線程池的最大線程數為Integer.MAX_VALUE、線程的空閑時間為60秒，此方式適合大量耗時短的任務、不適合大量耗時長的任務。

*由于創建的都是普通線程，且空閑時間為60秒，則仍有可能會頻繁的創建線程。

FixedThreadPool

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

FixedThreadPool創建的都是核心線程，其線程個數由入參決定，線程不會因為空閑時間而被銷毀，適合預知任務數量的業務。

SingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
  return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,new LinkedBlockingQueue<Runnable>()));
}

SingleThreadExecutor使用一個核心線程來處理任務。

ScheduledThreadPool

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

*ScheduledThreadPool支持定時執行任務以及固定間隔執行任務。

SingleThreadScheduledExecutor

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
    return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1));
}

*SingleThreadScheduledExecutor支持一個線程的定時執行任務以及固定間隔執行任務。

public interface ScheduledExecutorService extends ExecutorService {

  /**
   * 在指定的延遲時間到達后執行任務一次
   */
  public ScheduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit);

  /**
   * 在指定的延遲時間到達后執行任務一次
   */
  public <V> ScheduledFuture<V> schedule(Callable<V> callable,long delay, TimeUnit unit);

  /**
   * 在指定的初始化延遲時間到達后執行任務一次,往后每隔period時間執行任務一次.
   */
  public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit);

  /**
   * 在指定的初始化延遲時間到達后執行任務一次,往后每次任務執行完畢后相隔delay時間執行任務一次.
   */
  public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit);

}

WorkStealingPool

public static ExecutorService newWorkStealingPool(int parallelism) {
    return new ForkJoinPool(parallelism,ForkJoinPool.defaultForkJoinWorkerThreadFactory,null, true);
}

WorkStealingPool創建一個并行級別的線程池，同一時刻最多只能有指定個數個線程正在執行任務，創建時直接指定同一時刻最多能允許的并行執行的線程個數即可，如果不傳則使用CPU的核數。

newWorkStealingPool方法內部返回一個ForkJoinPool實例，ForkJoinPool是JAVA7新提供的線程池，同樣繼承AbstactExecutorService。

*作用類似于Semaphore。

以上就是Java中線程池的作用有哪些，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。