JAVA線程池原理詳解二

時間  2019-11-24
標籤 java 線程 原理 詳解 欄目 Java 简体版
原文   原文鏈接

Executor框架的兩級調度模型

在HotSpot VM的模型中，JAVA線程被一對一映射爲本地操做系統線程。JAVA線程啓動時會建立一個本地操做系統線程，當JAVA線程終止時，對應的操做系統線程也被銷燬回收，而操做系統會調度全部線程並將它們分配給可用的CPU。小程序

在上層，JAVA程序會將應用分解爲多個任務，而後使用應用級的調度器（Executor）將這些任務映射成固定數量的線程；在底層，操做系統內核將這些線程映射到硬件處理器上。服務器

Executor框架類圖

在前面介紹的JAVA線程既是工做單元，也是執行機制。而在Executor框架中，咱們將工做單元與執行機制分離開來。Runnable和Callable是工做單元（也就是俗稱的任務），而執行機制由Executor來提供。這樣一來Executor是基於生產者消費者模式的，提交任務的操做至關於生成者，執行任務的線程至關於消費者。框架

一、從類圖上看，Executor接口是異步任務執行框架的基礎，該框架可以支持多種不一樣類型的任務執行策略。dom

public interface Executor {

    void execute(Runnable command);
}

Executor接口就提供了一個執行方法，任務是Runnbale類型，不支持Callable類型。異步


二、ExecutorService接口實現了Executor接口，主要提供了關閉線程池和submit方法：ide

public interface ExecutorService extends Executor {

    List<Runnable> shutdownNow();


    boolean isTerminated();


    <T> Future<T> submit(Callable<T> task);

 }

另外該接口有兩個重要的實現類：ThreadPoolExecutor與ScheduledThreadPoolExecutor。spa

其中ThreadPoolExecutor是線程池的核心實現類，用來執行被提交的任務；而ScheduledThreadPoolExecutor是一個實現類，能夠在給定的延遲後運行任務，或者按期執行命令。操作系統

在上一篇文章中，我是使用ThreadPoolExecutor來經過給定不一樣的參數從而建立本身所需的線程池，可是在後面的工做中不建議這種方式，推薦使用Exectuors工廠方法來建立線程池線程

這裏先來區別線程池和線程組（ThreadGroup與ThreadPoolExecutor）這兩個概念：code

a、線程組就表示一個線程的集合。

b、線程池是爲線程的生命週期開銷問題和資源不足問題提供解決方案，主要是用來管理線程。

Executors能夠建立3種類型的ThreadPoolExecutor：SingleThreadExecutor、FixedThreadExecutor和CachedThreadPool

a、SingleThreadExecutor：單線程線程池

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

咱們從源碼來看能夠知道，單線程線程池的建立也是經過ThreadPoolExecutor，裏面的核心線程數和線程數都是1，而且工做隊列使用的是無界隊列。因爲是單線程工做，每次只能處理一個任務，因此後面全部的任務都被阻塞在工做隊列中，只能一個個任務執行。

b、FixedThreadExecutor：固定大小線程池

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

這個與單線程相似，只是建立了固定大小的線程數量。

c、CachedThreadPool:無界線程池

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

無界線程池意味着沒有工做隊列，任務進來就執行，線程數量不夠就建立，與前面兩個的區別是：空閒的線程會被回收掉，空閒的時間是60s。這個適用於執行不少短時間異步的小程序或者負載較輕的服務器。

Callable、Future、FutureTash詳解

Callable與Future是在JAVA的後續版本中引入進來的，Callable相似於Runnable接口，實現Callable接口的類與實現Runnable的類都是能夠被線程執行的任務。

三者之間的關係：

Callable是Runnable封裝的異步運算任務。

Future用來保存Callable異步運算的結果

FutureTask封裝Future的實體類

一、Callable與Runnbale的區別

a、Callable定義的方法是call，而Runnable定義的方法是run。

b、call方法有返回值，而run方法是沒有返回值的。

c、call方法能夠拋出異常，而run方法不能拋出異常。

二、Future

Future表示異步計算的結果，提供瞭如下方法，主要是判斷任務是否完成、中斷任務、獲取任務執行結果

 1 public interface Future<V> {
 2 
 3     boolean cancel(boolean mayInterruptIfRunning);
 4 
 5     boolean isCancelled();
 6 
 7     boolean isDone();
 8 
 9     V get() throws InterruptedException, ExecutionException;
10 
11     V get(long timeout, TimeUnit unit)
12         throws InterruptedException, ExecutionException, TimeoutException;
13 }

三、FutureTask<V>

可取消的異步計算，此類提供了對Future的基本實現，僅在計算完成時才能獲取結果，若是計算還沒有完成，則阻塞get方法。

public class FutureTask<V> implements RunnableFuture<V>
public interface RunnableFuture<V> extends Runnable, Future<V>

FutureTask不只實現了Future接口，還實現了Runnable接口，因此不只能夠將FutureTask當成一個任務交給Executor來執行，還能夠經過Thread來建立一個線程。

Callable與FutureTask

定義一個callable的任務：

 1 public class MyCallableTask implements Callable<Integer>
 2 {
 3     @Override
 4     public Integer call()
 5         throws Exception
 6     {
 7         System.out.println("callable do somothing");
 8         Thread.sleep(5000);
 9         return new Random().nextInt(100);
10     }
11 }
 1 public class CallableTest
 2 {
 3     public static void main(String[] args) throws Exception
 4     {
 5         Callable<Integer> callable = new MyCallableTask();
 6         FutureTask<Integer> future = new FutureTask<Integer>(callable);
 7         Thread thread = new Thread(future);
 8         thread.start();
 9         Thread.sleep(100);
10         //嘗試取消對此任務的執行
11         future.cancel(true);
12         //判斷是否在任務正常完成前取消
13         System.out.println("future is cancel:" + future.isCancelled());
14         if(!future.isCancelled())
15         {
16             System.out.println("future is cancelled");
17         }
18         //判斷任務是否已完成
19         System.out.println("future is done:" + future.isDone());
20         if(!future.isDone())
21         {
22             System.out.println("future get=" + future.get());
23         }
24         else
25         {
26             //任務已完成
27             System.out.println("task is done");
28         }
29     }
30 }

執行結果：

callable do somothing
future is cancel:true
future is done:true
task is done

這個DEMO主要是經過調用FutureTask的狀態設置的方法，演示了狀態的變遷。

a、第11行，嘗試取消對任務的執行，該方法若是因爲任務已完成、已取消則返回false，若是可以取消還未完成的任務，則返回true，該DEMO中因爲任務還在休眠狀態，因此能夠取消成功。

future.cancel(true);

b、第13行，判斷任務取消是否成功：若是在任務正常完成前將其取消，則返回true

System.out.println("future is cancel:" + future.isCancelled());

c、第19行，判斷任務是否完成：若是任務完成，則返回true，如下幾種狀況都屬於任務完成：正常終止、異常或者取消而完成。

    咱們的DEMO中，任務是因爲取消而致使完成。

 System.out.println("future is done:" + future.isDone());

d、在第22行，獲取異步線程執行的結果，我這個DEMO中沒有執行到這裏，須要注意的是，future.get方法會阻塞當前線程， 直到任務執行完成返回結果爲止。

System.out.println("future get=" + future.get());

Callable與Future

public class CallableThread implements Callable<String>
{
    @Override
    public String call()
        throws Exception
    {
        System.out.println("進入Call方法，開始休眠，休眠時間爲：" + System.currentTimeMillis());
        Thread.sleep(10000);
        return "今天停電";
    }
    
    public static void main(String[] args) throws Exception
    {
        ExecutorService es = Executors.newSingleThreadExecutor();
        Callable<String> call = new CallableThread();
        Future<String> fu = es.submit(call);
        es.shutdown();
        Thread.sleep(5000);
        System.out.println("主線程休眠5秒，當前時間" + System.currentTimeMillis());
        String str = fu.get();
        System.out.println("Future已拿到數據，str=" + str + ";當前時間爲：" + System.currentTimeMillis());
    }
}

執行結果：

進入Call方法，開始休眠，休眠時間爲：1478606602676
主線程休眠5秒，當前時間1478606608676
Future已拿到數據，str=今天停電;當前時間爲：1478606612677

這裏的future是直接扔到線程池裏面去執行的。因爲要打印任務的執行結果，因此從執行結果來看，主線程雖然休眠了5s，可是從Call方法執行到拿到任務的結果，這中間的時間差正好是10s，說明get方法會阻塞當前線程直到任務完成。

經過FutureTask也能夠達到一樣的效果：

 

public static void main(String[] args) throws Exception
    {
      ExecutorService es = Executors.newSingleThreadExecutor();
      Callable<String> call = new CallableThread();
      FutureTask<String> task = new FutureTask<String>(call);
      es.submit(task);
      es.shutdown();
      Thread.sleep(5000);
      System.out.println("主線程等待5秒，當前時間爲：" + System.currentTimeMillis());
      String str = task.get();
      System.out.println("Future已拿到數據，str=" + str + ";當前時間爲：" + System.currentTimeMillis());
    }

以上的組合能夠給咱們帶來這樣的一些變化：

若有一種場景中，方法A返回一個數據須要10s,A方法後面的代碼運行須要20s，可是這20s的執行過程當中，只有後面10s依賴於方法A執行的結果。若是與以往同樣採用同步的方式，勢必會有10s的時間被浪費，若是採用前面兩種組合，則效率會提升：

一、先把A方法的內容放到Callable實現類的call()方法中

二、在主線程中經過線程池執行A任務

三、執行後面方法中10秒不依賴方法A運行結果的代碼

四、獲取方法A的運行結果，執行後面方法中10秒依賴方法A運行結果的代碼

這樣代碼執行效率一會兒就提升了，程序沒必要卡在A方法處。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程