1 线程池

1.1 为何使用线程池

提问：为何要使用线程池？
答：
- 系统启动一个新线程的成本比较高，利用线程池可以很好地提高性能；
- 使用线程池可以有效地控制系统中并发线程的数量，避免因大量的并发线程的存在而导致系统性能下降甚至JVM崩溃。
线程池工作原理？
答：线程池在系统启动时就会创建大量空闲的线程，程序将一个Runnable对象或Callable对象传给线程池，线程池就会启动一个线程来执行它们的run()或call()方法，当run()或call()方法执行结束后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待下一个Runnable对象或Callable对象的run()或call()方法。

1.2 创建线程池的方法

Java中有个Executors工厂类包含如下7个静态工厂方法可以创建线程池，可以分为三大类：

下面3个方法返回一个ExecutorService对象，即线程池，可以执行Runnable对象或Callable对象所代表的线程

newCachedThreadPool()：创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将会被缓存在线程池中；
newFixedThreadPool(int nThreads)：创建一个可重用的、具有固定线程数的线程池；
newSingleThreadExecutor()：创建一个只有单线程的线程池，它相当于调用newFixedThreadPool()方法时传入参数为1；

下面2个方法返回一个ScheduledExecutorService对象，它是ExecutorService的子类

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

下面2个方法返回一个ExecutorService对象，是Java 8新增的方法，这两个方法可以充分利用多CPU并行的能力，并且生成的线程池相当于后台线程池，当前台线程都死亡了，该线程池中的线程会自动死亡

newWorkStealingPool(int parallelism)：创建持有足够的线程的线程池来支持给定的并行级别，该方法还会使用多个队列来减少竞争；
newWorkStealingPool()：上面方法的简化版本，根据当前机器的CPU个数设定并行级别，例如有4个CPU，则会传入4作为参数。

1.3 线程池分类及具体使用

ExecutorService：代表尽快执行线程的线程池，即只要线程池中有空闲线程，就立即执行线程任务。
ScheduledExecutorService：代表可在指定延迟后或周期性地执行线程任务的线程池

使用线程池来执行线程任务的步骤：

调用Executors类的静态工厂方法创建一个ExecutorService(或其子类)对象——线程池；
创建Runnable实现类或Callable实现类的实例，作为线程执行任务；
调用ExecutorService对象的submit()方法类提交Runnable或Callable实现类的实例；
若无任何任务要提交时，调用ExecutorService对象的shutdown()方法来关闭线程池。

另外，还可以调用线程池的shutdownNow()方法来关闭线程池，该方法试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。

2 ForkJoinPool

为了充分利用多CPU、多核CPU的优势，可以考虑把一个任务拆分成多个“小任务”并行计算，把多个小任务放到多个处理器核心上并行执行，当多个“小任务”执行完毕后，再将这些执行结果合并起来即可。

Java 7提供了ForkJoinPool来支持上述功能。ForkJoinPool是ExecutorService的实现类，因此是一种特殊的线程池，并且其提供了两个常用的构造器：

ForkJoinPool(int parallelism)：创建一个包含parallelism个并行线程的ForkJoinPool；
ForkJoinPool()：简化版，以Runtime.availableProcessors()方法的返回值作为parallelism参数来创建ForkJoinPool。

创建了ForkJoinPool实例之后，就可以调用其submit(ForkJoinTask task)或invoke(ForkJoinTask task)方法来执行指定的任务了。其中ForkJoinTask是一个可以并行、合并的任务，它是一个抽现类，它有两个抽象子类：RecursiveAction（无返回值任务）和RecursiveTask（有返回值任务）。下面我们要借助RecursiveAction来实现任务拆分的效果。

创建一个任务继承RecursiveAction以实现“可分解”任务，并实现其compute方法。

public 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() {
        //小于该门槛则开始打印，不再进行任务分解
        if (end - start < THRESHOLD) {
            for (int i = start; i < end; i++) {
                System.out.println(Thread.currentThread().getName() + "的i值：" + i);
            }
        } else {//否则分解为2个小任务
            int middle = (start + end) / 2;

            PrintTask left = new PrintTask(start, middle);
            PrintTask right = new PrintTask(middle, end);

            //执行任务
            left.fork();
            right.fork();
        }
    }
}

创建一个测试类ForkJoinPoolTest，具体步骤见注释

public class ForkJoinPoolTest {
    public static void main(String[] args) throws InterruptedException {
        //1、创建ForkJoinPool对象
        ForkJoinPool pool = new ForkJoinPool();

        //2、提交分解的PrintTask任务
        pool.submit(new PrintTask(0, 300));
        pool.awaitTermination(2, TimeUnit.SECONDS);

        //3、关闭线程池
        pool.shutdown();
    }
}

运行程序后结果如下：ForkJoinPool开启了4个线程来执行这个打印任务——代表我的电脑是4核的CPU。并且打印结果并不连续，这时因为分解后的任务会并行执行。

3 ThreadLocal

ThreadLocal即Thread Local Variable——线程局部变量的意思，通过将一个变量放入ThreadLocal当中，然后它为每一个使用该变量的线程都提供一个变量值的副本，使每一个线程都可以独立地改变自己的副本，而不会和其他线程的副本发生冲突。该类提供了3个public方法：

T get()：返回此线程局部变量中当前线程的副本中的值；
void remove()：删除此线程局部变量中当前线程的值；
void set(T value)：设置此线程局部变量中当前下城的副本中的值。

ThreadLocal并不能替代同步机制，，两者面向的问题领域不同。同步机制是为了同步多个线程对同一个资源的并发访问，是多个线程之间进行通信的有效方式；而ThreadLocal类是为了隔离多个线程的数据共享，从根本上避免多个线程之间对共享资源的竞争，从而就不需要对多个线程进行同步了。

建议：若多个线程之间需要共享资源以达到线程之间的通信功能，那就使用同步机制；若仅需隔离多个线程之间的共享冲突，则可以使用ThreadLocall。

4 包装线程不安全的集合

我们平常所用的ArrayList、LinkedList、HashSet、HashMap都是线程不安全的，可以通过Collections提供的类方法把这些集合包装成线程安全的集合，如下几个静态方法：

static Collection synchronizedCollection(Collection c)
static List synchronizedList(List list)
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
static Set synchronizedSet(Set s)
static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
static SortedSet synchronizedSortedSet(SortedSet s)

说明：以上静态方法均返回指定的对象对应的线程安全的对象，并且应该在创建集合之后立即包装。

Map<String, Integer> map = Collections.synchronizedMap(new HashMap<>());

Java多线程（四）

文章目录