image.png

1. 執(zhí)行器服務 ExecutorService

java.util.concurrent.ExecutorService 接口表示一個異步執(zhí)行機制，使我們能夠在后臺執(zhí)行任務。因此一個 ExecutorService 很類似于一個線程池。實際上，存在于 java.util.concurrent 包里的 ExecutorService 實現(xiàn)就是一個線程池實現(xiàn)。

ExecutorService 例子

以下是一個簡單的 ExecutorService 例子：


ExecutorService executorService = Executors.newFixedThreadPool(10);  
  
executorService.execute(new Runnable() {  
    public void run() {  
        System.out.println("Asynchronous task");  
    }  
});  
  
executorService.shutdown();

首先使用 newFixedThreadPool() 工廠方法創(chuàng)建一個 ExecutorService。這里創(chuàng)建了一個十個線程執(zhí)行任務的線程池。然后，將一個 Runnable 接口的匿名實現(xiàn)類傳遞給 execute() 方法。這將導致 ExecutorService 中的某個線程執(zhí)行該 Runnable。

任務委派

下圖說明了一個線程是如何將一個任務委托給一個 ExecutorService 去異步執(zhí)行的：

image.png

一個線程將一個任務委派給一個 ExecutorService 去異步執(zhí)行。

一旦該線程將任務委派給 ExecutorService，該線程將繼續(xù)它自己的執(zhí)行，獨立于該任務的執(zhí)行。

ExecutorService 實現(xiàn)

既然 ExecutorService 是個接口，如果你想用它的話就得去使用它的實現(xiàn)類之一。

java.util.concurrent 包提供了 ExecutorService 接口的以下實現(xiàn)類：

ThreadPoolExecutor
ScheduledThreadPoolExecutor

創(chuàng)建一個 ExecutorService

ExecutorService 的創(chuàng)建依賴于你使用的具體實現(xiàn)。但是你也可以使用 Executors 工廠類來創(chuàng)建 ExecutorService 實例。

以下是幾個創(chuàng)建 ExecutorService 實例的例子：


ExecutorService executorService1 = Executors.newSingleThreadExecutor();  
  
ExecutorService executorService2 = Executors.newFixedThreadPool(10);  
  
ExecutorService executorService3 = Executors.newScheduledThreadPool(10);

ExecutorService 使用

有幾種不同的方式來將任務委托給 ExecutorService 去執(zhí)行：

execute(Runnable)
submit(Runnable)
submit(Callable)
invokeAny(...)
invokeAll(...)

接下來我們挨個看一下這些方法。

execute(Runnable)

execute(Runnable) 方法要求一個 java.lang.Runnable 對象，然后對它進行異步執(zhí)行。以下是使用 ExecutorService 執(zhí)行一個 Runnable 的示例：


ExecutorService executorService = Executors.newSingleThreadExecutor();  
  
executorService.execute(new Runnable() {  
    public void run() {  
        System.out.println("Asynchronous task");  
    }  
});  
  
executorService.shutdown();

沒有辦法得知被執(zhí)行的 Runnable 的執(zhí)行結(jié)果。如果有需要的話你得使用一個 Callable(以下將做介紹)。

submit(Runnable)

submit(Runnable) 方法也要求一個 Runnable 實現(xiàn)類，但它返回一個 Future 對象。這個 Future 對象可以用來檢查 Runnable 是否已經(jīng)執(zhí)行完畢。以下是 ExecutorService submit() 示例：


Future future = executorService.submit(new Runnable() {  
    public void run() {  
        System.out.println("Asynchronous task");  
    }  
});  
  
future.get();  //returns null if the task has finished correctly.

submit(Callable)

submit(Callable) 方法類似于 submit(Runnable) 方法，除了它所要求的參數(shù)類型之外。Callable 實例除了它的 call() 方法能夠返回一個結(jié)果之外和一個 Runnable 很相像。Runnable.run() 不能夠返回一個結(jié)果。Callable 的結(jié)果可以通過 submit(Callable) 方法返回的 Future 對象進行獲取。

以下是一個 ExecutorService Callable 示例：


Future future = executorService.submit(new Callable(){  
    public Object call() throws Exception {  
        System.out.println("Asynchronous Callable");  
        return "Callable Result";  
    }  
});  
  
System.out.println("future.get() = " + future.get());

以上代碼輸出：
Asynchronous Callable
future.get() = Callable Result

invokeAny()

invokeAny() 方法要求一系列的 Callable 或者其子接口的實例對象。調(diào)用這個方法并不會返回一個 Future，但它返回其中一個 Callable 對象的結(jié)果。無法保證返回的是哪個 Callable 的結(jié)果 - 只能表明其中一個已執(zhí)行結(jié)束。

如果其中一個任務執(zhí)行結(jié)束(或者拋了一個異常)，其他 Callable 將被取消。以下是示例代碼：


ExecutorService executorService = Executors.newSingleThreadExecutor();  
  
Set<Callable<String>> callables = new HashSet<Callable<String>>();  
  
callables.add(new Callable<String>() {  
    public String call() throws Exception {  
        return "Task 1";  
    }  
});  
callables.add(new Callable<String>() {  
    public String call() throws Exception {  
        return "Task 2";  
    }  
});  
callables.add(new Callable<String>() {  
    public String call() throws Exception {  
        return "Task 3";  
    }  
});  
  
String result = executorService.invokeAny(callables);  
  
System.out.println("result = " + result);  
  
executorService.shutdown();

上述代碼將會打印出給定 Callable 集合中的一個的執(zhí)行結(jié)果。我自己試著執(zhí)行了它幾次，結(jié)果始終在變。有時是 "Task 1"，有時是 "Task 2" 等等。

invokeAll()

invokeAll() 方法將調(diào)用你在集合中傳給 ExecutorService 的所有 Callable 對象。invokeAll() 返回一系列的 Future 對象，通過它們你可以獲取每個 Callable 的執(zhí)行結(jié)果。記住，一個任務可能會由于一個異常而結(jié)束，因此它可能沒有 "成功"。

無法通過一個 Future 對象來告知我們是兩種結(jié)束中的哪一種。以下是一個代碼示例：


ExecutorService executorService = Executors.newSingleThreadExecutor();  
  
Set<Callable<String>> callables = new HashSet<Callable<String>>();  
  
callables.add(new Callable<String>() {  
    public String call() throws Exception {  
        return "Task 1";  
    }  
});  
callables.add(new Callable<String>() {  
    public String call() throws Exception {  
        return "Task 2";  
    }  
});  
callables.add(new Callable<String>() {  
    public String call() throws Exception {  
        return "Task 3";  
    }  
});  
  
List<Future<String>> futures = executorService.invokeAll(callables);  
  
for(Future<String> future : futures){  
    System.out.println("future.get = " + future.get());  
}  
  
executorService.shutdown();

ExecutorService 關閉

使用完 ExecutorService 之后你應該將其關閉，以使其中的線程不再運行。

比如，如果你的應用是通過一個 main() 方法啟動的，之后 main 方法退出了你的應用，如果你的應用有一個活動的 ExexutorService 它將還會保持運行。ExecutorService 里的活動線程阻止了 JVM 的關閉。

要終止 ExecutorService 里的線程你需要調(diào)用 ExecutorService 的 shutdown() 方法。ExecutorService 并不會立即關閉，但它將不再接受新的任務，而且一旦所有線程都完成了當前任務的時候，ExecutorService 將會關閉。在 shutdown() 被調(diào)用之前所有提交給 ExecutorService 的任務都被執(zhí)行。如果你想要立即關閉 ExecutorService，你可以調(diào)用 shutdownNow() 方法。這樣會立即嘗試停止所有執(zhí)行中的任務，并忽略掉那些已提交但尚未開始處理的任務。無法擔保執(zhí)行任務的正確執(zhí)行。可能它們被停止了，也可能已經(jīng)執(zhí)行結(jié)束。

2. 線程池執(zhí)行者 ThreadPoolExecutor

java.util.concurrent.ThreadPoolExecutor 是 ExecutorService 接口的一個實現(xiàn)。ThreadPoolExecutor 使用其內(nèi)部池中的線程執(zhí)行給定任務(Callable 或者 Runnable)。

ThreadPoolExecutor 包含的線程池能夠包含不同數(shù)量的線程。池中線程的數(shù)量由以下變量決定：

corePoolSize
maximumPoolSize

當一個任務委托給線程池時，如果池中線程數(shù)量低于 corePoolSize，一個新的線程將被創(chuàng)建，即使池中可能尚有空閑線程。如果內(nèi)部任務隊列已滿，而且有至少 corePoolSize 正在運行，但是運行線程的數(shù)量低于 maximumPoolSize，一個新的線程將被創(chuàng)建去執(zhí)行該任務。

ThreadPoolExecutor 圖解：

image.png

** 一個 ThreadPoolExecutor **

創(chuàng)建一個 ThreadPoolExecutor

ThreadPoolExecutor 有若干個可用構(gòu)造子。比如：


int  corePoolSize  =    5;  
int  maxPoolSize   =   10;  
long keepAliveTime = 5000;  
  
ExecutorService threadPoolExecutor =  
        new ThreadPoolExecutor(  
                corePoolSize,  
                maxPoolSize,  
                keepAliveTime,  
                TimeUnit.MILLISECONDS,  
                new LinkedBlockingQueue<Runnable>()  
                );

但是，除非你確實需要顯式為 ThreadPoolExecutor 定義所有參數(shù)，使用 java.util.concurrent.Executors 類中的工廠方法之一會更加方便，正如 ExecutorService 小節(jié)所述。

3. 定時執(zhí)行者服務 ScheduledExecutorService

java.util.concurrent.ScheduledExecutorService 是一個 ExecutorService，它能夠?qū)⑷蝿昭雍髨?zhí)行，或者間隔固定時間多次執(zhí)行。任務由一個工作者線程異步執(zhí)行，而不是由提交任務給 ScheduledExecutorService 的那個線程執(zhí)行。

ScheduledExecutorService 例子

以下是一個簡單的 ScheduledExecutorService 示例：

ScheduledExecutorService scheduledExecutorService =  
        Executors.newScheduledThreadPool(5);  
  
ScheduledFuture scheduledFuture =  
    scheduledExecutorService.schedule(new Callable() {  
        public Object call() throws Exception {  
            System.out.println("Executed!");  
            return "Called!";  
        }  
    },  
    5,  
    TimeUnit.SECONDS);

首先一個內(nèi)置 5 個線程的 ScheduledExecutorService 被創(chuàng)建。之后一個 Callable 接口的匿名類示例被創(chuàng)建然后傳遞給 schedule() 方法。后邊的倆參數(shù)定義了 Callable 將在 5 秒鐘之后被執(zhí)行。

ScheduledExecutorService 實現(xiàn)

既然 ScheduledExecutorService 是一個接口，你要用它的話就得使用 java.util.concurrent 包里對它的某個實現(xiàn)類。ScheduledExecutorService 具有以下實現(xiàn)類：ScheduledThreadPoolExecutor

創(chuàng)建一個 ScheduledExecutorService
如何創(chuàng)建一個 ScheduledExecutorService 取決于你采用的它的實現(xiàn)類。但是你也可以使用 Executors 工廠類來創(chuàng)建一個 ScheduledExecutorService 實例。比如：


ScheduledExecutorService scheduledExecutorService =  
  
        Executors.newScheduledThreadPool(5);

ScheduledExecutorService 使用

一旦你創(chuàng)建了一個 ScheduledExecutorService，你可以通過調(diào)用它的以下方法：

schedule (Callable task, long delay, TimeUnit timeunit)
schedule (Runnable task, long delay, TimeUnit timeunit)
scheduleAtFixedRate (Runnable, long initialDelay, long period, TimeUnit timeunit)
scheduleWithFixedDelay (Runnable, long initialDelay, long period, TimeUnit timeunit)

下面我們就簡單看一下這些方法。

schedule (Callable task, long delay, TimeUnit timeunit)

這個方法計劃指定的 Callable 在給定的延遲之后執(zhí)行。這個方法返回一個 ScheduledFuture，通過它你可以在它被執(zhí)行之前對它進行取消，或者在它執(zhí)行之后獲取結(jié)果。以下是一個示例：


ScheduledExecutorService scheduledExecutorService =  
        Executors.newScheduledThreadPool(5);  
  
ScheduledFuture scheduledFuture =  
    scheduledExecutorService.schedule(new Callable() {  
        public Object call() throws Exception {  
            System.out.println("Executed!");  
            return "Called!";  
        }  
    },  
    5,  
    TimeUnit.SECONDS);  
  
System.out.println("result = " + scheduledFuture.get());  
  
scheduledExecutorService.shutdown();

示例輸出結(jié)果：
Executed!
result = Called!

schedule (Runnable task, long delay, TimeUnit timeunit)

除了 Runnable 無法返回一個結(jié)果之外，這一方法工作起來就像以一個 Callable 作為一個參數(shù)的那個版本的方法一樣，因此 ScheduledFuture.get() 在任務執(zhí)行結(jié)束之后返回 null。

scheduleAtFixedRate (Runnable, long initialDelay, long period, TimeUnit timeunit)

這一方法規(guī)劃一個任務將被定期執(zhí)行。該任務將會在首個 initialDelay 之后得到執(zhí)行，然后每個 period 時間之后重復執(zhí)行。如果給定任務的執(zhí)行拋出了異常，該任務將不再執(zhí)行。如果沒有任何異常的話，這個任務將會持續(xù)循環(huán)執(zhí)行到 ScheduledExecutorService 被關閉。如果一個任務占用了比計劃的時間間隔更長的時候，下一次執(zhí)行將在當前執(zhí)行結(jié)束執(zhí)行才開始。計劃任務在同一時間不會有多個線程同時執(zhí)行。

scheduleWithFixedDelay (Runnable, long initialDelay, long period, TimeUnit timeunit)

除了 period 有不同的解釋之外這個方法和 scheduleAtFixedRate() 非常像。

scheduleAtFixedRate() 方法中，period 被解釋為前一個執(zhí)行的開始和下一個執(zhí)行的開始之間的間隔時間。而在本方法中，period 則被解釋為前一個執(zhí)行的結(jié)束和下一個執(zhí)行的結(jié)束之間的間隔。因此這個延遲是執(zhí)行結(jié)束之間的間隔，而不是執(zhí)行開始之間的間隔。

ScheduledExecutorService 關閉

正如 ExecutorService，在你使用結(jié)束之后你需要把 ScheduledExecutorService 關閉掉。否則他將導致 JVM 繼續(xù)運行，即使所有其他線程已經(jīng)全被關閉。

你可以使用從 ExecutorService 接口繼承來的 shutdown() 或 shutdownNow() 方法將 ScheduledExecutorService 關閉。參見 ExecutorService 關閉部分以獲取更多信息。

4. 使用 ForkJoinPool 進行分叉和合并

ForkJoinPool 在 Java 7 中被引入。它和 ExecutorService 很相似，除了一點不同。ForkJoinPool 讓我們可以很方便地把任務分裂成幾個更小的任務，這些分裂出來的任務也將會提交給 ForkJoinPool。任務可以繼續(xù)分割成更小的子任務，只要它還能分割。可能聽起來有些抽象，因此本節(jié)中我們將會解釋 ForkJoinPool 是如何工作的，還有任務分割是如何進行的。

分叉和合并解釋

在我們開始看 ForkJoinPool 之前我們先來簡要解釋一下分叉和合并的原理。
分叉和合并原理包含兩個遞歸進行的步驟。兩個步驟分別是分叉步驟和合并步驟。

分叉

一個使用了分叉和合并原理的任務可以將自己分叉(分割)為更小的子任務，這些子任務可以被并發(fā)執(zhí)行。如下圖所示：

image.png

通過把自己分割成多個子任務，每個子任務可以由不同的 CPU 并行執(zhí)行，或者被同一個 CPU 上的不同線程執(zhí)行。只有當給的任務過大，把它分割成幾個子任務才有意義。把任務分割成子任務有一定開銷，因此對于小型任務，這個分割的消耗可能比每個子任務并發(fā)執(zhí)行的消耗還要大。

什么時候把一個任務分割成子任務是有意義的，這個界限也稱作一個閥值。這要看每個任務對有意義閥值的決定。很大程度上取決于它要做的工作的種類。

合并

當一個任務將自己分割成若干子任務之后，該任務將進入等待所有子任務的結(jié)束之中。一旦子任務執(zhí)行結(jié)束，該任務可以把所有結(jié)果合并到同一個結(jié)果。圖示如下：

image.png

當然，并非所有類型的任務都會返回一個結(jié)果。如果這個任務并不返回一個結(jié)果，它只需等待所有子任務執(zhí)行完畢。也就不需要結(jié)果的合并啦。

ForkJoinPool

ForkJoinPool 是一個特殊的線程池，它的設計是為了更好的配合分叉-和-合并任務分割的工作。ForkJoinPool 也在 java.util.concurrent 包中，其完整類名為 java.util.concurrent.ForkJoinPool。

創(chuàng)建一個 ForkJoinPool

你可以通過其構(gòu)造子創(chuàng)建一個 ForkJoinPool。作為傳遞給 ForkJoinPool 構(gòu)造子的一個參數(shù)，你可以定義你期望的并行級別。并行級別表示你想要傳遞給 ForkJoinPool 的任務所需的線程或 CPU 數(shù)量。以下是一個 ForkJoinPool 示例：


ForkJoinPool forkJoinPool = new ForkJoinPool(4);

這個示例創(chuàng)建了一個并行級別為 4 的 ForkJoinPool。

提交任務到 ForkJoinPool

就像提交任務到 ExecutorService 那樣，把任務提交到 ForkJoinPool。你可以提交兩種類型的任務。一種是沒有任何返回值的(一個 "行動")，另一種是有返回值的(一個"任務")。這兩種類型分別由 RecursiveAction 和 RecursiveTask 表示。接下來介紹如何使用這兩種類型的任務，以及如何對它們進行提交。

RecursiveAction

RecursiveAction 是一種沒有任何返回值的任務。它只是做一些工作，比如寫數(shù)據(jù)到磁盤，然后就退出了。一個 RecursiveAction 可以把自己的工作分割成更小的幾塊，這樣它們可以由獨立的線程或者 CPU 執(zhí)行。你可以通過繼承來實現(xiàn)一個 RecursiveAction。示例如下：


import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.RecursiveAction;  
  
public class MyRecursiveAction extends RecursiveAction {  
  
    private long workLoad = 0;  
  
    public MyRecursiveAction(long workLoad) {  
        this.workLoad = workLoad;  
    }  
  
    @Override  
    protected void compute() {  
  
        //if work is above threshold, break tasks up into smaller tasks  
        if(this.workLoad > 16) {  
            System.out.println("Splitting workLoad : " + this.workLoad);  
  
            List<MyRecursiveAction> subtasks =  
                new ArrayList<MyRecursiveAction>();  
  
            subtasks.addAll(createSubtasks());  
  
            for(RecursiveAction subtask : subtasks){  
                subtask.fork();  
            }  
  
        } else {  
            System.out.println("Doing workLoad myself: " + this.workLoad);  
        }  
    }  
  
    private List<MyRecursiveAction> createSubtasks() {  
        List<MyRecursiveAction> subtasks =  
            new ArrayList<MyRecursiveAction>();  
  
        MyRecursiveAction subtask1 = new MyRecursiveAction(this.workLoad / 2);  
        MyRecursiveAction subtask2 = new MyRecursiveAction(this.workLoad / 2);  
  
        subtasks.add(subtask1);  
        subtasks.add(subtask2);  
  
        return subtasks;  
    }  
  
}

例子很簡單。MyRecursiveAction 將一個虛構(gòu)的 workLoad 作為參數(shù)傳給自己的構(gòu)造子。如果 workLoad 高于一個特定閥值，該工作將被分割為幾個子工作，子工作繼續(xù)分割。如果 workLoad 低于特定閥值，該工作將由 MyRecursiveAction 自己執(zhí)行。你可以這樣規(guī)劃一個 MyRecursiveAction 的執(zhí)行：


MyRecursiveAction myRecursiveAction = new MyRecursiveAction(24);  
  
forkJoinPool.invoke(myRecursiveAction);

RecursiveTask

RecursiveTask 是一種會返回結(jié)果的任務。它可以將自己的工作分割為若干更小任務，并將這些子任務的執(zhí)行結(jié)果合并到一個集體結(jié)果。可以有幾個水平的分割和合并。以下是一個 RecursiveTask 示例：


import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.RecursiveTask;  
      
      
public class MyRecursiveTask extends RecursiveTask<Long> {  
  
    private long workLoad = 0;  
  
    public MyRecursiveTask(long workLoad) {  
        this.workLoad = workLoad;  
    }  
  
    protected Long compute() {  
  
        //if work is above threshold, break tasks up into smaller tasks  
        if(this.workLoad > 16) {  
            System.out.println("Splitting workLoad : " + this.workLoad);  
  
            List<MyRecursiveTask> subtasks =  
                new ArrayList<MyRecursiveTask>();  
            subtasks.addAll(createSubtasks());  
  
            for(MyRecursiveTask subtask : subtasks){  
                subtask.fork();  
            }  
  
            long result = 0;  
            for(MyRecursiveTask subtask : subtasks) {  
                result += subtask.join();  
            }  
            return result;  
  
        } else {  
            System.out.println("Doing workLoad myself: " + this.workLoad);  
            return workLoad * 3;  
        }  
    }  
      
    private List<MyRecursiveTask> createSubtasks() {  
        List<MyRecursiveTask> subtasks =  
        new ArrayList<MyRecursiveTask>();  
  
        MyRecursiveTask subtask1 = new MyRecursiveTask(this.workLoad / 2);  
        MyRecursiveTask subtask2 = new MyRecursiveTask(this.workLoad / 2);  
  
        subtasks.add(subtask1);  
        subtasks.add(subtask2);  
  
        return subtasks;  
    }  
}

除了有一個結(jié)果返回之外，這個示例和 RecursiveAction 的例子很像。MyRecursiveTask 類繼承自 RecursiveTask<Long>，這也就意味著它將返回一個 Long 類型的結(jié)果。

MyRecursiveTask 示例也會將工作分割為子任務，并通過 fork() 方法對這些子任務計劃執(zhí)行。

此外，本示例還通過調(diào)用每個子任務的 join() 方法收集它們返回的結(jié)果。子任務的結(jié)果隨后被合并到一個更大的結(jié)果，并最終將其返回。對于不同級別的遞歸，這種子任務的結(jié)果合并可能會發(fā)生遞歸。

你可以這樣規(guī)劃一個 RecursiveTask：


MyRecursiveTask myRecursiveTask = new MyRecursiveTask(128);  
  
long mergedResult = forkJoinPool.invoke(myRecursiveTask);  
  
System.out.println("mergedResult = " + mergedResult);

注意是如何通過 ForkJoinPool.invoke() 方法的調(diào)用來獲取最終執(zhí)行結(jié)果的。

ForkJoinPool 評論

貌似并非每個人都對 Java 7 里的 ForkJoinPool 滿意：《一個 Java 分叉-合并帶來的災禍》。

在你計劃在自己的項目里使用 ForkJoinPool 之前最好讀一下該篇文章。

個人介紹：

** 高廣超** ：多年一線互聯(lián)網(wǎng)研發(fā)與架構(gòu)設計經(jīng)驗，擅長設計與落地高可用、高性能互聯(lián)網(wǎng)架構(gòu)。目前就職于美團網(wǎng)，負責核心業(yè)務研發(fā)工作。

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Java 并發(fā)工具包-常用線程池

Java 并發(fā)工具包-常用線程池

1. 執(zhí)行器服務 ExecutorService

ExecutorService 例子

任務委派

ExecutorService 實現(xiàn)

創(chuàng)建一個 ExecutorService

ExecutorService 使用

execute(Runnable)

submit(Runnable)

submit(Callable)

invokeAny()

invokeAll()

ExecutorService 關閉

2. 線程池執(zhí)行者 ThreadPoolExecutor

創(chuàng)建一個 ThreadPoolExecutor

3. 定時執(zhí)行者服務 ScheduledExecutorService

ScheduledExecutorService 例子

ScheduledExecutorService 實現(xiàn)

ScheduledExecutorService 使用

schedule (Callable task, long delay, TimeUnit timeunit)

schedule (Runnable task, long delay, TimeUnit timeunit)

scheduleAtFixedRate (Runnable, long initialDelay, long period, TimeUnit timeunit)

scheduleWithFixedDelay (Runnable, long initialDelay, long period, TimeUnit timeunit)

ScheduledExecutorService 關閉

4. 使用 ForkJoinPool 進行分叉和合并

分叉和合并解釋

分叉

合并

ForkJoinPool

創(chuàng)建一個 ForkJoinPool

提交任務到 ForkJoinPool

RecursiveAction

RecursiveTask

ForkJoinPool 評論

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Java 并發(fā)工具包-常用線程池

1. 執(zhí)行器服務 ExecutorService

ExecutorService 例子

任務委派

ExecutorService 實現(xiàn)

創(chuàng)建一個 ExecutorService

ExecutorService 使用

execute(Runnable)

submit(Runnable)

submit(Callable)

invokeAny()

invokeAll()

ExecutorService 關閉

2. 線程池執(zhí)行者 ThreadPoolExecutor

創(chuàng)建一個 ThreadPoolExecutor

3. 定時執(zhí)行者服務 ScheduledExecutorService

ScheduledExecutorService 例子

ScheduledExecutorService 實現(xiàn)

ScheduledExecutorService 使用

schedule (Callable task, long delay, TimeUnit timeunit)

schedule (Runnable task, long delay, TimeUnit timeunit)

scheduleAtFixedRate (Runnable, long initialDelay, long period, TimeUnit timeunit)

scheduleWithFixedDelay (Runnable, long initialDelay, long period, TimeUnit timeunit)

ScheduledExecutorService 關閉

4. 使用 ForkJoinPool 進行分叉和合并

分叉和合并解釋

分叉

合并

ForkJoinPool

創(chuàng)建一個 ForkJoinPool

提交任務到 ForkJoinPool

RecursiveAction

RecursiveTask

ForkJoinPool 評論

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频