Java线程池

时间 2019-11-08

标签 java 线程栏目 Java 繁體版

原文原文链接

Java线程池

1. 简介

系统启动一个新线程的成本是比较高的，由于它涉及与操做系统的交互，这个时候使用线程池能够提高性能，尤为是须要建立大量声明周期很短暂的线程时。Java中的线程池是运用场景最多的并发框架。java

线程池相似于数据库链接池，在系统启动的时候即建立大量空闲的线程，能够将一个线程任务提交给线程池执行，当任务执行完后，线程不会死亡，而是再次返回线程池中成为空闲状态。数据库

使用线程池的好处

下降资源消耗：重复利用下降建立和销毁线程的消耗；
提升响应速度：任务来了能够理解执行，没必要等待线程建立；
提升线程的可管理性：使用线程池能够统一的分配、调优和监控。

2. 使用Executors工厂类来产生线程

Executors工厂类主要有4种方式生产线程池：小程序

1.newCachedThreadPool() ：建立一个具备缓存功能的线程池，线程池无边界，适用于执行不少短时间异步任务的小程序，或者负载较轻的服务器。数组

2. newFixedThreadPool(int nThreads)：建立一个固定线程数的线程池，适用于为了知足资源管理的要求而须要限制线程数量的场景，好比负载较重的服务器。缓存

3. newSingleThreadExecutor()：建立一个只有单线程的线程池，适用于须要保证顺序地执行各个任务，而且在任意时间点不会有多个线程是活动的西场景。服务器

4. newScheduledThreadPool(int corePoolSize)：建立一个具备指定线程数的线程池，并能够在指定延迟后执行线程任务，适用于多个后台线程执行周期任务，同时为了知足资源管理须要限制线程数量的场景。并发

实例代码

package com.wangjun.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/*
 * 演示线程池的使用
 */
public class ThreadPoolTest {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        
        //生产普通的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(6);
        // 第一种执行线程的方式
        threadPool.submit(new MyThread()); 
        // 第二种执行线程的方式，有返回值
        Future<String> result = threadPool.submit(new MyThread(), "返回值1"); 
        System.out.println(result.get());
        // 第三种执行线程的方式，传入Callable对象，有返回值
        Future<String> result2 = threadPool.submit(new MyThread2()); 
        System.out.println(result2.get());
        
        // 关闭线程池,再也不接受新的任务，会将以前全部提交的任务执行完成，全部任务完成后，全部的线程死亡
        // 调用shutdownNow能够立马中止全部线程
        threadPool.shutdown();
        System.out.println("-----");
        // 生产能够延迟执行的线程池
        ScheduledExecutorService threadPool2 = Executors.newScheduledThreadPool(6);
        // 延迟1秒执行
        threadPool2.schedule(new MyThread(), 1, TimeUnit.SECONDS);
        // 延迟2秒后执行，每一秒循环执行一次
        // 是以上一个任务开始的时间计时，period时间过去后，检测上一个任务是否执行完毕，若是上一个任务执行完毕，
        // 则当前任务当即执行，若是上一个任务没有执行完毕，则须要等上一个任务执行完毕后当即执行。
        threadPool2.scheduleAtFixedRate(new MyThread(), 2, 1, TimeUnit.SECONDS);
        // 是以上一个任务结束时开始计时，period时间过去后，当即执行。
        // 两个方法以不一样的时间点做为参考
        threadPool2.scheduleWithFixedDelay(new MyThread(), 2, 1, TimeUnit.SECONDS);
        
        Thread.sleep(3000);
        threadPool2.shutdown();
    }

    static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("线程：" + Thread.currentThread().getName());
        }
    }
    
    static class MyThread2 implements Callable<String>{
        @Override
        public String call() throws Exception {
            System.out.println("线程：" + Thread.currentThread().getName());
            return "返回值2";
        }
    }

}

3. 线程池类ThreadPoolExector

上面使用Executors工厂类生产线程池，其实大部分返回的就是ThreadPoolExector的实例。ThreadPoolExector才是真正的线程池。框架

3.1 线程池的几个关键属性

核心线程数量corePoolSize：核心线程数，指保留的线程池大小（不超过maximumPoolSize值时，线程池中最多有corePoolSize 个线程工做）。
最大线程数量maximumPoolSize：指的是线程池的最大大小，使用使用了无界队列，那这个参数就没什么用。
线程结束的超时时间keepAliveTime：当一个线程不工做时，过keepAliveTime时间将中止该线程（该线程是多余的，指大于corePoolSize的那些线程）。
存听任务的队列workQueue：存放须要被线程池执行的线程队列。
饱和策略handler：加任务失败后如何处理该任务。一般是AbortPolicy，表示没法处理新任务时抛出异常。

3.2 线程池执行策略

线程池执行execute()方法的过程如图：异步

线程池刚建立时，里面没有一个线程。任务队列是做为参数传进来的。不过，就算队列里面有任务，线程池也不会立刻执行它们。
当调用 execute() 方法添加一个任务时，线程池会作以下判断：

a. 若是正在运行的线程数量小于 corePoolSize，则建立线程执行任务（注意，这一步须要获取全局锁）；ide

b. 若是正在运行的线程数量大于或等于 corePoolSize而且队列没有满，那么将这个任务放入队列。

c. 若是这时候队列满了，并且正在运行的线程数量小于 maximumPoolSize，那么仍是要建立线程运行这个任务；

d. 若是队列满了，并且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会交给配置的执行策略处理（调用RejectedExecutionHandler.rejectedExecution方法），好比抛出异常，提示没法加入新线程。

当一个线程完成任务时，它会从队列中取下一个任务来执行。
当一个线程无事可作，超过必定的时间（keepAliveTime）时，线程池会判断，若是当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。因此线程池的全部任务完成后，它最终会收缩到 corePoolSize 的大小。

3.3 线程池中阻塞队列的种类

ArrayBlockingQueue：居于数组结构的有界阻塞队列，按照先进先出FIFO原则对元素进行排序；
LinkedBlockingQueue：基于链表结构的阻塞队列，按照FIFO排序原色，吞吐量大于ArrayBlockingQueue，静态工厂方法Executors.newFixedThreadPool()就使用了这个队列；
SynchronousQueue：不存储元素的阻塞队列。每一个插入操做必须等到另外一个线程调用移除操做，不然插入操做一直处于阻塞状态，吞吐量一般要高于LinkedBlockingQueue，静态工程方法Executors.newCachedThreadPool()就使用了这个队列；
PriorityBlockingQueue：具备优先级的无限阻塞队列。

3.4 饱和策略

通常状况下，线程池采用的是AbortPolicy，表示没法处理新任务时抛出异常。JDK1.5中java线程池框架提供了4种饱和策略：

AbortPolicy：直接抛出异常；
CallerRunsPolicy：使用调用者所在线程来运行任务；
DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务；
DiscardPolicy：不处理，丢弃掉。

也能够根据场景来实现RejectedExecutionHandler接口来自定义策略。

3.5 向线程池提交任务

execute：用于提交不须要返回值的任务，所以没法判断任务是否被线程执行成功；
submit：用于提交须要有返回值的任务，返回一个Future对象，经过get()获取返回值，会阻塞当前线程直到任务完成。

3.6 关闭线程池

经过调用线程池的shutdown和shutdownNow方法来关闭线程池，他们的原理是遍历线程池中的工做线程，而后逐个调用线程的interrupt方法来中断线程，因此没法影响中断的任务可能永远没法终止。

这两个方法的区别是shutdownNow首先将线程池的状态设置为STOP，而后尝试中止全部的正在执行或暂停任务的线程，并返回等待任务的列表，而shutdown只是将线程池的状态设置为SHUTDOWN状态，而后中断全部没有正在执行任务的线程。

只要调用了这两个关闭方法中的任意一个，isShutdown方法就会返回true，当全部的任务都已关闭后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true。一般调用shutdown来关闭线程池，若是任务不必定要执行完，则能够调用shutdownNow方法。

4. Executor框架

JDK5以前，java的线程Thread既是工做单元，也是执行单元（start方法执行），JDK5开始，把工做单元与执行机制分离开来，工做单元包括Runnable和Callable，而执行机制由Executor框架提供。（注意这里的Executor和Executors线程池工厂类不是一回事。）

线程池类ThreadPoolExecutor的继承关系：

ThreadPoolExecutor -> AbstractExecutorService -> ExecutorService(接口) -> Executor(接口)。

能够看到ThreadPoolExecutor就是Executor接口的一个实现方法。

4.1 Executor的两层调度模型

传统的java线程（java.lang.Thread）在JVM中被一对一映射为本地操做系统线程，java线程启动时会建立一个本地操做系统线程，当java线程终止时，这个操做系统线程也会被回收。

而在Executor框架中，将用户任务映射为固定数量的线程，在底层操做系统内核将这些线程映射到硬件处理器上，应用程序经过Executor框架控制上层调度，下层的调度由操做系统内核控制。

4.2 Executor框架的结构

Executor框架主要有3部分组成：

任务：包括被执行任务须要实现的接口：Runnable和Callable；
任务的执行：核心接口是Executor，继承Executor的ExecutorService接口。ExecutorService接口有两个核心实现类，ThreadPoolExecutor和ScheduledThreadPoolExecutor（继承ThreadPoolExecutor，能够延迟执行任务，比Timer更强大）。
异步计算的结果：包括接口Future和实现Future接口的FutureTask类。

来看一下Executor框架中主要类和接口的UML图：