系统启动一个线程的成本是比较高,使用线程池可以很好地提高性能,尤其是当程序中需要创建大量生存期很短暂的线程时

线程池在系统启动时即创建大量空闲线程,将一个Runnable、Callable对象—–>传给线程池—–>线程池启动里面的一个线程来执行它们的run()或者call()方法———->当线程执行体执行完成后,线程并不会死亡,而是再次返回线程池成为空闲状态,等待下一个Runnable、Callable对象的run()或者call()方法

Java8改进的线程池

Executors工厂类

Java5开始,Java内建支持线程池。Executors工厂类来产生线程池,该工厂类包含如下几个静态工厂方法来创建线程池:

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

  • ExecutorService newFixedThreadPool(int nThreads):创建一个可重用的、具有nThread个固定的线程的线程池

  • ExecutorService newSingleThreadExecutor():创建包含一个只有单线程的线程池,相当于调用newFixedThreadPool(1)

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

  • ScheduledExecutorService newSingleThreadScheduledExecutor():创建只有一个线程的线程池,可以指定延迟后执行线程任务

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

  • ExecutorService newWorkStealingPool():该方法可以看做是前一个方法的简本,并行级别不需要用户手工指定,是根据计算机CPU个数自动生成的,如果当前机器有6个CPU,则调用该方法时并行级别被设为6

前三个方法返回一个ExecutorService对象,代表一个线程池,可以执行Runnable对象和Callable对象所代表的线程;中间两个方法返回一个ScheduledExecutorService对象,它是ExecutorService的子类,可以在指定延迟后执行线程任务;最后两个方法生成的work stealing池,相当于后台线程池,如果所有的前台线程都死亡了,work stealig池中的线程也会自动死亡

ExecutorService

ExecutorService代表尽快执行线程的线程池(只要线程中有空闲线程就立即执行线程任务),程序只要将一个Runnable对象或Callable对象(代表线程任务)提交给该线程池,该线程池就会尽快执行该任务

ExecutorService里提供了如下3个方法:

  • 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

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

  • ScheduledFuture<V> schedule(Callable<V> 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()方法来关闭线程池,该方法试图停止所有正在执行的活动任务,暂停处理正在等待的任务,并返回等待的任务列表

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

  1. 调用Executor类的静态工厂方法创建一个ExecutorService对象,该对象代表一个线程池

  2. 创建Runnable或Callable接口实现类的实例,作为线程执行任务

  3. 调用ExcutorService的submit方法来提交Runnable或Callable实例

  4. 当不想提交任何任务时调用ExcutorService的shutdown()方法来关闭线程池

import java.util.concurrent.*;

public class ThreadPoolTest
{
    public static void main(String[] args)
        throws Exception
    {
        // 创建足够的线程来支持4个CPU并行的线程池
        // 创建一个具有固定线程数(6)的线程池
        ExecutorService pool = Executors.newFixedThreadPool(6);
        // 使用Lambda表达式创建Runnable对象
        Runnable target = () -> {
            for (int i = 0; i < 100 ; i++ )
            {
                System.out.println(Thread.currentThread().getName() + "的i值为:" + i);
            }
        };
        // 向线程池中提交两个线程
        pool.submit(target);
        pool.submit(target);
        // 关闭线程池
        pool.shutdown();
    }
}

Java8增强的ForkJoinPool

Java7提供了ForkJoinPool支持将一个任务拆分成多个“小任务”并行计算,再把多个“小任务”的结果合并成总的计算结果。ForkJoinPool是ExecutorService的实现类,是一种特殊的线程池

ForkJoinService提供了如下两个常用的构造器:

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

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

Jav增加通用池功能,由如下两个静态方法提供通用池功能:

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

  • int getCommonPollParallelism():该方法返回通用池的并行级别

创建ForkJoinPool实例可调用ForkJoinPool的submit(ForkJoinTask task)或invoke(ForkJoinTask task)方法来执行指定任务了。其中ForkJoinTask代表一个可以并行、合并的任务

ForkJoinTask是一个抽象类,它有两个抽象子类:RecursiveAction和RecursiveTask。其中RecursiveTask代表有返回值的任务,RecursiveAction代表没有返回值的任务

线程池工具类的类图:
clipboard.png

使用RecursiveAction执行没有返回值的“大任务”

简单打印0~500的数值:

import java.util.concurrent.*;

// 继承RecursiveAction来实现"可分解"的任务
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 < 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;
            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 , 500));
        pool.awaitTermination(2, TimeUnit.SECONDS);
        // 关闭线程池
        pool.shutdown();
    }
}

程序实现了对指定打印任务的分解,分解后的任务分别调用fork()方法开始并行执行。ForkJoinPool启动了4个线程来执行打印任务
clipboard.png

使用RecursiveTask<T>执行有返回值的“大任务”

对一个长度为100的数值的元素值进行累加:

import java.util.concurrent.*;
import java.util.*;

// 继承RecursiveTask来实现"可分解"的任务
class CalTask extends RecursiveTask<Integer>
{
    // 每个“小任务”只最多只累加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 < THRESHOLD)
        {
            for (int i = start ; i < end ; i++ )
            {
                sum += arr[i];
            }
            return sum;
        }
        else
        {
            // 如果当end与start之间的差大于THRESHOLD时,即要累加的数超过20个时
            // 将大任务分解成两个小任务。
            int middle = (start + end) / 2;
            CalTask left = new CalTask(arr, start, 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 < len ; i++ )
        {
            int tmp = rand.nextInt(20);
            // 对数组元素赋值,并将数组元素的值添加到sum总和中。
            total += (arr[i] = tmp);
        }
        System.out.println(total);
        // 创建一个通用池
        ForkJoinPool pool = ForkJoinPool.commonPool();
        // 提交可分解的CalTask任务
        Future<Integer> future = pool.submit(new CalTask(arr, 0, arr.length));
        System.out.println(future.get());
        // 关闭线程池
        pool.shutdown();
    }
}

布still
461 声望32 粉丝

数据挖掘、用户行为研究、用户画像