详细分析JAVA 线程池

详细分析JAVA 线程池

系统启动一个新线程的成本是比较高的，因为它涉及与操作系统交互。在这种情形下，使用线程池可以很好地提高性能，尤其是当程序中需要创建大量生存期很短暂的线程时，更应该考虑使用线程池。

与数据库连接池类似的是，线程池在系统启动时即创建大量空闲的线程，程序将一个 Runnable 对象或 Callable 对象传给线程池，线程池就会启动一个线程来执行它们的 run() 或 call() 方法，当 run() 或 call() 方法执行结束后，该线程并不会死亡，而是再次返回线程池成为空闲状态，等待执行下一个 Runnable 对象的 run() 或 call() 方法。

除此之外，使用线程池可以有效地控制系统中并发线程的数量，当系统中包含大量并发线程时，会导致系统性能剧烈下降，甚至导致 JVM 崩溃，而线程池的最大线程数参数可以控制系统中并发线程数不超过此数。

java 8 改进的线程池

在 Java 5 以前，开发者必须手动实现自己的线程池；从 Java 5 开始， Java 内建支持线程池。 Java 5 新增了一个 Executors 工厂类来产生线程池，该工厂类包含如下几个静态工厂方法来创建线程池。

newCachedThreadPool()：创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将会被缓存在线程池中。

newFixedThreadPool(int nThreads)：创建一个可重用的、具有固定线程数的线程池。

newSingleThreadExecutor()：创建一个只有单线程的线程池，它相当于调用 newFixedThreadPool() 方法时传入参数为1。

newScheduledThreadPool(int corePoolSize)：创建具有指定线程数的线程池，它可以在指定延迟后执行线程任务。 corePoolSize 指池中所保存的线程数，即使线程是空闲的也被保存在线程池内。

newSingleThreadScheduledExecutor()：创建只有一个线程的线程池，它可以在指定延迟后执行线程任务。

ExecutorService newWorkStealingPool(int parallelism)：创建持有足够的线程的线程池来支持给定的并行级别，该方法还会使用多个队列来减少竞争。

ExecutorService newWorkStealingPool()：该方法是前一个方法的简化版本。如果当前机器有 4 个CPU, 则目标并行级别被设置为 4，也就是相当于为前一个方法传入 4 作为参数。

上面7个方法中的前三个方法返回一个 ExecutorService 对象，该对象代表一个线程池，它可以执行 Runnable 对象或 Callable 对象所代表的线程；而中间两个方法返回一个 ScheduledExecutorService 线程池，它是 ExecutorService 的子类，它可以在指定延迟后执行线程任务；最后两个方法则是 Java 8 新增的，这两个方法可充分利用多 CPU 并行的能力。这两个方法生成的 work stealing 池，都相当于后台线程池，如果所有的前台线程都死亡了，work stealing 池中的线程会自动死亡。

由于目前计算机硬件的发展日新月异，即使普通用户使用的电脑通常也都是多核 CPU，因此 Java 8 在线程支持上也增加了利用多 CPU 并行的能力，这样可以更好地发挥底层硬件的性能。

ExecutorService 代表尽快执行线程的线程池（只要线程池中有空闲线程，就立即执行线程任务），程序只要将一个 Runnable 对象或 Callable 对象（代表线程任务）提交给该线程池，该线程池就会尽快执行该任务。 ExecutorService 里提供了如下三个方法。

Future >  submit(Runnable task)：将一个 Runnable 对象提交给指定的线程池，线程池将在有空闲线程时执行 Runnable 对象代表的任务。其中 Future 对象代表 Runnable 任务的返回值，但 run() 方法没有返回值，所以 Future 对象将在 run() 方法执行结束后返回 null 。但可以调用 Futuhttp://re 的 isDone()、 isCancelled() 方法来获得 Runnable 对象的执行状态。

Future   submit(Runnable task,  T result)：将一个 Runnable 对象提交给指定的线程池，线程池将在有空闲线程时执行 Runnable 对象代表的任务。其中 result 显式指定线程执行结束后的返回值，所以 Future 对象将在 run() 方法执行结束后返回 result 。

Future   submit(Callable    task)：将一个 Callable 对象提交给指定的线程池，线程池将在有空闲线程时执行 Callable 对象代表的任务。其中 Future 代表 Callable 对象里 call() 方法的返回值。

ScheduledExecutorService 代表可在指定延迟后或周期性地执行线程任务的线程池，它提供了如下4个方法。

ScheduledFuture  schedule (Callable  callable,  long delay, TimeUnit unit)：指定 callable 任务将在 delay 延迟后执行。

ScheduledFuture>  schedule(Runnable command , long delay , TimeUnit unit)：指定 command 任务将在 delay 延迟后执行。

ScheduledFuture>  scheduleAtFixedRate(Runnable command,  long initialDelay,  long period , TimeUnit unit) : 指定 command 任务将在 delay 延迟后执行，而且以设定频率重复执行。也就是说，在 initialDelay 后开始执行，依次在 initialDelay + period 、 initialDelay +2* period …处重复执行，依此类推。

ScheduledFuture>   scheduleWithFixedDelay(Runnable command,  long initialDelay,  long delay, TimeUnit unit)：创建并执行一个在给定初始延迟后首次启用的定期操作，随后在每一次执行终止和下一次执行开始之间都存在给定的延迟。如果任务在任一次执行时遇到异常，就会取消后续执行；否则，只能通过程序来显式取消或终止该任务。

用完一个线程池后，应该调用该线程池的 shutdown() 方法，该方法将启动线程池的关闭序列，调用 shutdown() 方法后的线程池不再接收新任务，但会将以前所有已提交任务执行完成。当线程池中的所有任务都执行完成后，池中的所有线程都会死亡；另外也可以调用线程池的 shutdownNow() 方法来关闭线程池，该方法试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。

使用线程池来执行线程任务的步骤如下。

调用 Executors 类的静态工厂方法创建一个 ExecutorService 对象，该对象代表一个线程池。

创建 Runnable 实现类或 Callable 实现类的实例，作为线程执行任务。

调用 ExecutorService 对象的 submit() 方法来提交 Runnable 实例或 Callable 实例。

当不想提交任何任务时，调用 Executorhttp://Service 对象的 shutdown() 方法来关闭线程池。

下面程序使用线程池来执行指定 Runnable 对象所代表的任务。

//实现Runnable接口来定义一个简单的

class TestThread implements Runnable{

public void run(){

for (int i = 0; i < 100 ; i++ ){

System.out.println(Thread.currentThread().getName()

+ "的i值为:" + i);

}

}

}

public class ThreadPoolTest{

public static void main(String[] args) {

//创建一个具有固定线程数（6）的线程池

ExecutorService pool = Executors.newFixedThreadPool(6);

//向线程池中提交2个线程

pool.submit(new TestThread());

pool.submit(new TestThread());

//关闭线程池

pool.shutdown();

}

}

上面程序中创建 Runnable 实现类与最开始创建线程池并没有太大差别，创建了 Runnable 实现类之后程序没有直接创建线程、启动线程来执行该 Runnable 任务，而是通过线程池来执行该任务，使用线程池来执行 Runnable 任务的代码如程序中粗体字代码所示。运行上面程序，将看到两个线程交替执行的效果，如下图所示。

Java 8  增强的 ForkJoinPool

现在计算机大多已向多 CPU 方向发展，即使普通 PC ，甚至小型智能设备（如手机）、多核处理器也已被广泛应用。在未来的日子里，处理器的核心数将会发展到更多。

虽然硬件上的多核 CPU 已经十分成熟，但很多应用程序并未为这种多核 CPU 做好准备，因此并不能很好地利用多核 CPU 的性能优势。

为了充分利用多 CPU 、多核 CPU 的性能优势，计算机软件系统应该可以充分“挖掘”每个 CPU 的计算能力，绝不能让某个 CPU 处于“空闲”状态。为了充分利用多 CPU 、多核 CPU 的优势，可以考虑把一个任务拆分成多个“小任务”，把多个“小任务”放到多个处理器核心上并行执行；当多个“小任务”执行完成之后，再将这些执行结果合并起来即可。

Java 7 提供了 ForkJoinPool 来支持将一个任务拆分成多个“小任务”并行计算，再把多个“小任务”的结果合并成总的计算结果。 ForkJoinPool 是 ExecutorService 的实现类，因此是一种特殊的线程池。ForkJoinPool 提供了如下两个常用的构造器。

ForkJoinPool(int parallelism)：创建一个包含 parallelism 个并行线程的 ForkJoinPool 。

ForkJoinPool()：以 Runtime.availableProcessors() 方法的返回值作为 parallelism 参数来创建 ForkJoinPool

Java 8 进一步扩展了 ForkJoinPool 的功能 ，Java 8 为 ForkJoinPool 增加了通用池功能。 ForkJoinPool 类通过如下两个静态方法提供通用池功能。

ForkJoinPool commonPool()：该方法返回一个通用池，通用池的运行状态不会受 shutdown() 或 shutdownNow() 方法的影响。当然，如果程序直接执行 System.exit(0); 来终止虚拟机，通用池以及通用池中正在执行的任务都会被自动终止。

int getCommonPoolParallelism()：该方法返回通用池的并行级别。

创建了 ForkJoinPool 实例之后，就可调用 ForkJoinPool 的 submit(ForkJoinTask task) 或 invoke(ForkJoinTask task) 方法来执行指定任务了。其中 ForkJoinTask 代表一个可以并行、合并的任务。ForkJoinTask 是一个抽象类，它还有两个抽象子类 ： RecursiveAction 和 RecursiveTask 。其中 RecursiveTask 代表有返回值的任务，而 RecursiveAction 代表没有返回值的任务。

下面以执行没有返回值的“大任务”（简单地打印0〜300的数值）为例，程序将一个“大任务”拆分成多个“小任务”，并将任务交给 ForkJoinPool 来执行。

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.RecursiveAction;

import java.util.concurrent.TimeUnit;

class PrintTask extends RecursiveAction{

// 每个“小任务”最多只打印50个数

private static final int THRESHOLD = 50;

private int start;

private int end;

// 打印从 start 到 end 的任务

public PrintTask(int start, int end) {

this.start = start;

this.end = end;

}

@Override

protected void compute() {

// 当 end 与 start 之间的差小于 THRESHOLD 时，开始打印

if(end-start

for(int i=start;i

System.out.println(Thread.currentThread().getName()+"的 i 值："+i);

}

}else {

// 当 end 与 start 之间的差大于 THRESHOLD 时，即要打印的数超过50个时

// 将大任务分解成两个“小任务”

int middle = (start+end)/2;

PrintTask left = new PrintTask(start, middle);

PrintTask right = new PrintTask(middle, end);

// 并行执行两个“小任务”

left.fork();

right.fork();

}

}

}

public class ForkJoinPoolTest {

public static void main(String[] args) throws Exception {

ForkJoinPool pool = new ForkJoinPool();

// 提交可分解的 PrintTask 任务

pool.submit(new PrintTask(0, 300));

pool.awaitTermination(2, TimeUnit.SECONDS);

// 关闭线程池

pool.shutdown();

}

}

上面程序中的粗体字代码实现了对指定打印任务的分解，分解后的任务分别调用 fork() 方法开始并行执行。运行上面程序，可以看到如下图所示的结果。

从如上图所示的执行结果来看， ForkJoinPool 启动了 4个线程来执行这个打印任务——这是因为测试计算机的 CPU 是4核的。不仅如此，读者可以看到程序虽然打印了 0〜299这300个数字，但并不是连续打印的，这是因为程序将这个打印任务进行了分解，分解后的任务会并行执行，所以不会按顺序从0打印到299。

上面定义的任务是一个没有返回值的打印任务，如果大任务是有返回值的任务，则可以让任务继承 RecursiveTask，其中泛型参数 T 就代表了该任务的返回值类型。下面程序示范了使用 RecursiveTask 对一个长度为100的数组的元素值进行累加。

package com.jwen.demo4;

import java.util.Random;

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.Future;

import java.util.concurrent.RecursiveTask;

import java.util.function.Function;

class CalTask extends RecursiveTask{

// 每个“小任务”最多只累加20个数

private static final int THRESHOLD = 20;

private int arr[];

private int start;

private int end;

// 累加从 start 到 end 的数组元素

public CalTask(int[] arr, int start, int end) {

this.arr = arr;

this.start = start;

this.end = end;

}

@Override

protected Integer compute() {

int sum = 0;

// 当 end 与 start 之间的差小于 THRESHOLD 时，开始进行实际累加

if(end-start

for(int i=start;i

sum+=arr[i];

}

return sum;

}else {

// 当 end 与 start 之间的差大于 THRESHOLD 时，即要累加的数超过20个时

// 将大任务分解成两个“小任务”

int middle = (start+end)/2;

CalTask left = new CalTask(arr, sxzEZwtart, middle);

CalTask right = new CalTask(arr, middle, end);

// 并行执行两个“小任务”

left.fork();

right.fork();

// 把两个“小任务”累加的结果合并起来

return left.join()+right.join(); // ①

}

}

}

public class Sum {

public static void main(String[] args) throws Exception{

int[] arr = new int[100];

Random rand = new Random();

int total = 0;

// 初始化100个数字元素

for(int i=0,len = arr.length;i

int tmp = rand.nextInt(20);

// 对数组元素赋值，并将数组元素的值添加到 sum 总和中

total +=(arr[i]=tmp);

}

System.out.println(total);

// 创建一个通用池

ForkJoinPool pool = ForkJoinPool.commonPool();

// 提交可分解的 CalTask 任务

Future future = pool.submit(new CalTask(arr, 0, arr.length));

System.out.println(future.get());

// 关闭线程池

pool.shutdown();

}

}

上面程序与前一个程序基本相似，同样是将任务进行了分解，并调用分解后的任务的 fork() 方法使它们并行执行。与前一个程序不同的是，现在任务是带返回值的，因此程序还在①号代码处将两个分解后的“小任务”的返回值进行了合并。

运行上面程序，将可以看到程序通过 CalTask 计算出来的总和，与初始化数组元素时统计出来的总和总是相等，这表明程序一切正常。

Java 的确是一门非常优秀的编程语言，在多 CPU、多核 CPU 时代来到时，Java 语言的多线程已经为多核 CPU 做好了准备。

以上就是详细分析JAVA 线程池的详细内容，更多关于JAVA 线程池的资料请关注我们其它相关文章！

for(int i=start;i

System.out.println(Thread.currentThread().getName()+"的 i 值："+i);

}

}else {

// 当 end 与 start 之间的差大于 THRESHOLD 时，即要打印的数超过50个时

// 将大任务分解成两个“小任务”

int middle = (start+end)/2;

PrintTask left = new PrintTask(start, middle);

PrintTask right = new PrintTask(middle, end);

// 并行执行两个“小任务”

left.fork();

right.fork();

}

}

}

public class ForkJoinPoolTest {

public static void main(String[] args) throws Exception {

ForkJoinPool pool = new ForkJoinPool();

// 提交可分解的 PrintTask 任务

pool.submit(new PrintTask(0, 300));

pool.awaitTermination(2, TimeUnit.SECONDS);

// 关闭线程池

pool.shutdown();

}

}

上面程序中的粗体字代码实现了对指定打印任务的分解，分解后的任务分别调用 fork() 方法开始并行执行。运行上面程序，可以看到如下图所示的结果。

从如上图所示的执行结果来看， ForkJoinPool 启动了 4个线程来执行这个打印任务——这是因为测试计算机的 CPU 是4核的。不仅如此，读者可以看到程序虽然打印了 0〜299这300个数字，但并不是连续打印的，这是因为程序将这个打印任务进行了分解，分解后的任务会并行执行，所以不会按顺序从0打印到299。

上面定义的任务是一个没有返回值的打印任务，如果大任务是有返回值的任务，则可以让任务继承 RecursiveTask，其中泛型参数 T 就代表了该任务的返回值类型。下面程序示范了使用 RecursiveTask 对一个长度为100的数组的元素值进行累加。

package com.jwen.demo4;

import java.util.Random;

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.Future;

import java.util.concurrent.RecursiveTask;

import java.util.function.Function;

class CalTask extends RecursiveTask{

// 每个“小任务”最多只累加20个数

private static final int THRESHOLD = 20;

private int arr[];

private int start;

private int end;

// 累加从 start 到 end 的数组元素

public CalTask(int[] arr, int start, int end) {

this.arr = arr;

this.start = start;

this.end = end;

}

@Override

protected Integer compute() {

int sum = 0;

// 当 end 与 start 之间的差小于 THRESHOLD 时，开始进行实际累加

if(end-start

for(int i=start;i

sum+=arr[i];

}

return sum;

}else {

// 当 end 与 start 之间的差大于 THRESHOLD 时，即要累加的数超过20个时

// 将大任务分解成两个“小任务”

int middle = (start+end)/2;

CalTask left = new CalTask(arr, sxzEZwtart, middle);

CalTask right = new CalTask(arr, middle, end);

// 并行执行两个“小任务”

left.fork();

right.fork();

// 把两个“小任务”累加的结果合并起来

return left.join()+right.join(); // ①

}

}

}

public class Sum {

public static void main(String[] args) throws Exception{

int[] arr = new int[100];

Random rand = new Random();

int total = 0;

// 初始化100个数字元素

for(int i=0,len = arr.length;i

int tmp = rand.nextInt(20);

// 对数组元素赋值，并将数组元素的值添加到 sum 总和中

total +=(arr[i]=tmp);

}

System.out.println(total);

// 创建一个通用池

ForkJoinPool pool = ForkJoinPool.commonPool();

// 提交可分解的 CalTask 任务

Future future = pool.submit(new CalTask(arr, 0, arr.length));

System.out.println(future.get());

// 关闭线程池

pool.shutdown();

}

}

上面程序与前一个程序基本相似，同样是将任务进行了分解，并调用分解后的任务的 fork() 方法使它们并行执行。与前一个程序不同的是，现在任务是带返回值的，因此程序还在①号代码处将两个分解后的“小任务”的返回值进行了合并。

运行上面程序，将可以看到程序通过 CalTask 计算出来的总和，与初始化数组元素时统计出来的总和总是相等，这表明程序一切正常。

Java 的确是一门非常优秀的编程语言，在多 CPU、多核 CPU 时代来到时，Java 语言的多线程已经为多核 CPU 做好了准备。

以上就是详细分析JAVA 线程池的详细内容，更多关于JAVA 线程池的资料请关注我们其它相关文章！

System.out.println(Thread.currentThread().getName()+"的 i 值："+i);

}

}else {

// 当 end 与 start 之间的差大于 THRESHOLD 时，即要打印的数超过50个时

// 将大任务分解成两个“小任务”

int middle = (start+end)/2;

PrintTask left = new PrintTask(start, middle);

PrintTask right = new PrintTask(middle, end);

// 并行执行两个“小任务”

left.fork();

right.fork();

}

}

}

public class ForkJoinPoolTest {

public static void main(String[] args) throws Exception {

ForkJoinPool pool = new ForkJoinPool();

// 提交可分解的 PrintTask 任务

pool.submit(new PrintTask(0, 300));

pool.awaitTermination(2, TimeUnit.SECONDS);

// 关闭线程池

pool.shutdown();

}

}

上面程序中的粗体字代码实现了对指定打印任务的分解，分解后的任务分别调用 fork() 方法开始并行执行。运行上面程序，可以看到如下图所示的结果。

从如上图所示的执行结果来看， ForkJoinPool 启动了 4个线程来执行这个打印任务——这是因为测试计算机的 CPU 是4核的。不仅如此，读者可以看到程序虽然打印了 0〜299这300个数字，但并不是连续打印的，这是因为程序将这个打印任务进行了分解，分解后的任务会并行执行，所以不会按顺序从0打印到299。

上面定义的任务是一个没有返回值的打印任务，如果大任务是有返回值的任务，则可以让任务继承 RecursiveTask，其中泛型参数 T 就代表了该任务的返回值类型。下面程序示范了使用 RecursiveTask 对一个长度为100的数组的元素值进行累加。

package com.jwen.demo4;

import java.util.Random;

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.Future;

import java.util.concurrent.RecursiveTask;

import java.util.function.Function;

class CalTask extends RecursiveTask{

// 每个“小任务”最多只累加20个数

private static final int THRESHOLD = 20;

private int arr[];

private int start;

private int end;

// 累加从 start 到 end 的数组元素

public CalTask(int[] arr, int start, int end) {

this.arr = arr;

this.start = start;

this.end = end;

}

@Override

protected Integer compute() {

int sum = 0;

// 当 end 与 start 之间的差小于 THRESHOLD 时，开始进行实际累加

if(end-start

for(int i=start;i

sum+=arr[i];

}

return sum;

}else {

// 当 end 与 start 之间的差大于 THRESHOLD 时，即要累加的数超过20个时

// 将大任务分解成两个“小任务”

int middle = (start+end)/2;

CalTask left = new CalTask(arr, sxzEZwtart, middle);

CalTask right = new CalTask(arr, middle, end);

// 并行执行两个“小任务”

left.fork();

right.fork();

// 把两个“小任务”累加的结果合并起来

return left.join()+right.join(); // ①

}

}

}

public class Sum {

public static void main(String[] args) throws Exception{

int[] arr = new int[100];

Random rand = new Random();

int total = 0;

// 初始化100个数字元素

for(int i=0,len = arr.length;i

int tmp = rand.nextInt(20);

// 对数组元素赋值，并将数组元素的值添加到 sum 总和中

total +=(arr[i]=tmp);

}

System.out.println(total);

// 创建一个通用池

ForkJoinPool pool = ForkJoinPool.commonPool();

// 提交可分解的 CalTask 任务

Future future = pool.submit(new CalTask(arr, 0, arr.length));

System.out.println(future.get());

// 关闭线程池

pool.shutdown();

}

}

上面程序与前一个程序基本相似，同样是将任务进行了分解，并调用分解后的任务的 fork() 方法使它们并行执行。与前一个程序不同的是，现在任务是带返回值的，因此程序还在①号代码处将两个分解后的“小任务”的返回值进行了合并。

运行上面程序，将可以看到程序通过 CalTask 计算出来的总和，与初始化数组元素时统计出来的总和总是相等，这表明程序一切正常。

Java 的确是一门非常优秀的编程语言，在多 CPU、多核 CPU 时代来到时，Java 语言的多线程已经为多核 CPU 做好了准备。

以上就是详细分析JAVA 线程池的详细内容，更多关于JAVA 线程池的资料请关注我们其它相关文章！

for(int i=start;i

sum+=arr[i];

}

return sum;

}else {

// 当 end 与 start 之间的差大于 THRESHOLD 时，即要累加的数超过20个时

// 将大任务分解成两个“小任务”

int middle = (start+end)/2;

CalTask left = new CalTask(arr, sxzEZwtart, middle);

CalTask right = new CalTask(arr, middle, end);

// 并行执行两个“小任务”

left.fork();

right.fork();

// 把两个“小任务”累加的结果合并起来

return left.join()+right.join(); // ①

}

}

}

public class Sum {

public static void main(String[] args) throws Exception{

int[] arr = new int[100];

Random rand = new Random();

int total = 0;

// 初始化100个数字元素

for(int i=0,len = arr.length;i

int tmp = rand.nextInt(20);

// 对数组元素赋值，并将数组元素的值添加到 sum 总和中

total +=(arr[i]=tmp);

}

System.out.println(total);

// 创建一个通用池

ForkJoinPool pool = ForkJoinPool.commonPool();

// 提交可分解的 CalTask 任务

Future future = pool.submit(new CalTask(arr, 0, arr.length));

System.out.println(future.get());

// 关闭线程池

pool.shutdown();

}

}

上面程序与前一个程序基本相似，同样是将任务进行了分解，并调用分解后的任务的 fork() 方法使它们并行执行。与前一个程序不同的是，现在任务是带返回值的，因此程序还在①号代码处将两个分解后的“小任务”的返回值进行了合并。

运行上面程序，将可以看到程序通过 CalTask 计算出来的总和，与初始化数组元素时统计出来的总和总是相等，这表明程序一切正常。

Java 的确是一门非常优秀的编程语言，在多 CPU、多核 CPU 时代来到时，Java 语言的多线程已经为多核 CPU 做好了准备。

以上就是详细分析JAVA 线程池的详细内容，更多关于JAVA 线程池的资料请关注我们其它相关文章！

sum+=arr[i];

}

return sum;

}else {

// 当 end 与 start 之间的差大于 THRESHOLD 时，即要累加的数超过20个时

// 将大任务分解成两个“小任务”

int middle = (start+end)/2;

CalTask left = new CalTask(arr, sxzEZwtart, middle);

CalTask right = new CalTask(arr, middle, end);

// 并行执行两个“小任务”

left.fork();

right.fork();

// 把两个“小任务”累加的结果合并起来

return left.join()+right.join(); // ①

}

}

}

public class Sum {

public static void main(String[] args) throws Exception{

int[] arr = new int[100];

Random rand = new Random();

int total = 0;

// 初始化100个数字元素

for(int i=0,len = arr.length;i

int tmp = rand.nextInt(20);

// 对数组元素赋值，并将数组元素的值添加到 sum 总和中

total +=(arr[i]=tmp);

}

System.out.println(total);

// 创建一个通用池

ForkJoinPool pool = ForkJoinPool.commonPool();

// 提交可分解的 CalTask 任务

Future future = pool.submit(new CalTask(arr, 0, arr.length));

System.out.println(future.get());

// 关闭线程池

pool.shutdown();

}

}

上面程序与前一个程序基本相似，同样是将任务进行了分解，并调用分解后的任务的 fork() 方法使它们并行执行。与前一个程序不同的是，现在任务是带返回值的，因此程序还在①号代码处将两个分解后的“小任务”的返回值进行了合并。

运行上面程序，将可以看到程序通过 CalTask 计算出来的总和，与初始化数组元素时统计出来的总和总是相等，这表明程序一切正常。

Java 的确是一门非常优秀的编程语言，在多 CPU、多核 CPU 时代来到时，Java 语言的多线程已经为多核 CPU 做好了准备。

以上就是详细分析JAVA 线程池的详细内容，更多关于JAVA 线程池的资料请关注我们其它相关文章！

int tmp = rand.nextInt(20);

// 对数组元素赋值，并将数组元素的值添加到 sum 总和中

total +=(arr[i]=tmp);

}

System.out.println(total);

// 创建一个通用池

ForkJoinPool pool = ForkJoinPool.commonPool();

// 提交可分解的 CalTask 任务

Future future = pool.submit(new CalTask(arr, 0, arr.length));

System.out.println(future.get());

// 关闭线程池

pool.shutdown();

}

}

上面程序与前一个程序基本相似，同样是将任务进行了分解，并调用分解后的任务的 fork() 方法使它们并行执行。与前一个程序不同的是，现在任务是带返回值的，因此程序还在①号代码处将两个分解后的“小任务”的返回值进行了合并。

运行上面程序，将可以看到程序通过 CalTask 计算出来的总和，与初始化数组元素时统计出来的总和总是相等，这表明程序一切正常。

Java 的确是一门非常优秀的编程语言，在多 CPU、多核 CPU 时代来到时，Java 语言的多线程已经为多核 CPU 做好了准备。

以上就是详细分析JAVA 线程池的详细内容，更多关于JAVA 线程池的资料请关注我们其它相关文章！

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。