谈谈线程池的那些笔记
一 . 线程池
系统启动一个新线程的成本是比较昂贵的，这中间涉及与操作系统交互。在这种情形下，使用线程池就可以很好地提高性能，尤其是当程序中需要创建大量生存期很短暂的线程时，更应该考虑使用线程池。
首先，线程池在系统启动时即创建大量空闲的线程，程序将一个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 ( int nThreads ) 方法时传入参数为 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 。但可以调用 Future 的 isDone ( ) 、 isCancelled ( ) 方法来获得 Runnable 对象的执行状态。
-
< T > Future < T > submit ( Runnable task , T result ) : 将一个 Runnable 对象提交给指定的线程，线程池将在有空闲线程时执行 Runnable 对象代表的任务。其中 result 显示指定线程执行结束后的返回值，所以 Future 对象将在 run ( ) 方法执行结束后返回 result 。
-
< T > future < T > submit (Callable < T > task ) : 将一个 Callable 对象提交给指定的线程池，线程池将在有空闲线程时执行 Callable 对象代表的任务。其中 Future 代表 Callable 对象里 call ( ) 方法的返回值。
ScheduledExecutorService 代表可在指定延迟后或周期性地执行线程任务的线程池，它提供了如下4个方法：
-
ScheduledFuture < V > schedule ( Callable < V > callable , long delay , TimeUnit unit ) :指定 callable 任务将在 delay 延迟后执行。
-
ScheduleFuture < V > 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···处重复执行，以此类推。
-
ScheduleFuture < ? > scheduleWithFixedDelay ( Runnable command , long initialDelay , kibg delay , TimeUnit unit ) : 创建并执行一个给定初始延迟后首次启用的定期操作，随后在每一次执行终止和下一次执行开始之间都存在给定的延迟。如果任务在任一次执行时遇到异常，就会取消后续执行；否则，只能通过程序来显式取消或终止该任务。
用完一个线程池后，应该调用该线程池的 shutdown ( ) 方法，该方法将启动线程池的关闭序列，调用 shutdown ( ) 方法后的线程池不再接收新任务，但会将以前所有已提交的任务执行完毕。当线程池中的所有任务都执行完后，池中的所有线程都会死亡；另外也可以调用线程池的 shutdownNow ( ) 方法来关闭线程池，该方法试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务的列表。
三 . 线程池的使用
使用线程池来执行线程任务的步骤如下：
-
调用 Executors 类的静态工厂方法创建一个 Executor Service 对象，该对象代表一个线程池。
-
创建 Runnable 实现类或 Callable 实现类的实例，作为线程执行任务。
-
调用 ExecutorService 对象的 submit ( ) 方法来提交 Runnable 实例或 Callable 实例。
-
当不想提交任何任务时，调用 ExecutorService 对象的 shutdown ( ) 方法来关闭线程池。
下面举一个例子来说明线程池的使用，代码如下：
public class ThreadPoolTest {
public static void main(String [] args)
throws Exception
{
//创建一个具有固定线程数（6）的线程池
ExecutorService pool=Executors.newFixedThreadPool(6);
//向线程池中提交两个线程
//pool.submit(task)
MyThread myThread =new MyThread();
pool.submit(myThread);
pool.submit(myThread);
//关闭线程池
pool.shutdown();
}
}
class MyThread implements Runnable
{
@Override
public void run() {
for(int i=0;i<5;i++)
{
System.out.println(Thread.currentThread().getName()+"的 i 的值为："+i);
}
}
}
上面程序中创建 Runnable 实例类与最开始创建线程池并没有太大差别， 创建了 Runnable 实现类之后程序没有直接创建线程、启动线程来执行该 Runnable 任务，而是通过线程池来执行该任务，运行上面程序，将看到两个线程交替执行的效果，如下入：
四 . 使用 Java 8 增强的 ForkJionPool
为了充分利用多 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 代表没有返回值的任务。其中，ForkJoinPool 、ForkJoinTask 等类的类图如下所示：
下面以简单打印0～300的数值（大任务）为例，程序将一个大任务拆分成多个小任务，并将任务交给 ForkJoinPool 来执行。代码如下：
public class ThreadPoolTest {
public static void main(String [] args)
throws Exception
{
ForkJoinPool pool=new ForkJoinPool();
//提交可拆分的 PrintTaskTest 任务
pool.submit(new PrintTaskTest(0,300));
pool.awaitTermination(2, TimeUnit.SECONDS);
//关闭线程池
pool.shutdown();
}
}
/*
* 继承 RecursiveAction 来实现拆分小任务
* */
class PrintTaskTest extends RecursiveAction
{
//每个小任务最多只能打印50个
private static final int THRESHOLD=50;
private int start;
private int end;
//打印从 start 到 end 的任务
public PrintTaskTest(int start ,int end )
{
this.start=start;
this.end=end;
}
@Override
protected void compute() {
//当 end 与 start 之间的差值小于 THRESHOLD 时，开始打印
if(end-start<THRESHOLD)
{
for(int i=start;i<end;i++)
{
System.out.println(Thread.currentThread().getName()+"的 i 值："+i);
}
}else
{
//当 end 与 start 之间的差大于 THRESHOLD ，即要打印的数超过50个时
//将大任务分解长两个小任务
int middle=(start+end)/2;
PrintTaskTest left=new PrintTaskTest(start,middle);
PrintTaskTest right=new PrintTaskTest(middle,end);
//并发执行两个小任务
left.fork();
right.fork();
}
}
}
上面程序实现了对指定打印任务的拆分，拆分后的任务分别调用 fork ( ) 方法开始并行执行。运行上面程序，可以看到结果如下图：
从上面的执行结果来看，ForkJoinPool 启动了6个线程来执行这个打印任务，这是因为测试机的 CPU 时6核的。不仅如此，程序打印了0～300个数字，并且不是连续打印的。
上面的例子是对于没有返回值的任务，如果大任务是有返回值的，那么可以任务继承 RecursiveTask < T > ，其中泛型参数 T 就代表了该任务的返回值类型，下面通过一个例子来说明 RecursiveTask 对一个长度为100的数组的元素值进行累加。代码如下：
//继承 RecursiveTask 来实现任务的拆分
class CaltTask extends RecursiveTask <Integer>
{
//每个小任务最多只能累加20个数
private static final int THRESHOLD=20;
private int arr[];
private int start;
private int end;
//累加从 start 到 end 的数组元素
public CaltTask(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 ，即要累加的数超过20个时将大任务拆分成两个小任务
if(end-start<THRESHOLD){
for(int i=start;i<end;i++)
{
sum+=arr[i];
}
return sum;
}
else
{
int middle=(start+end)/2;
CaltTask left=new CaltTask(arr,start,middle);
CaltTask right=new CaltTask(arr,middle,end);
//并行执行两个小任务
left.fork();
right.fork();
//把两个小任务累加的结果合并起来
return left.join()+right.join();
}
}
}
public class SumDemo {
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;i<arr.length;i++)
{
int tmp=rand.nextInt(20);
//对数组元素赋值，并将数组元素的值添加到 sum 总和中
total+=(arr[i]=tmp);
}
System.out.println("对数组赋值后累加的结果：total="+total);
//创建一个通用池
ForkJoinPool pool=ForkJoinPool.commonPool();
//提交可拆分的 CaltTask任务
Future<Integer> future=pool.submit(new CaltTask(arr,0,arr.length));
System.out.println("通过 CaltTask计算出来的结果："+future.get());
//关闭线程池
pool.shutdown();
}
}
运行结果如下所示：
扫一扫
115
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
