线程池技术详解-优快云博客

本文链接：https://blog.youkuaiyun.com/zw147258369/article/details/97930301

技术背景

在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁。如何利用已有对象来服务就是一个需要解决的关键问题，其实这就是一些"池化资源"技术产生的原因。比如大家所熟悉的数据库连接池正是遵循这一思想而产生的，本文将介绍的线程池技术同样符合这一思想。

概念

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。

java中常见线程池的使用

所有实现了ExecutorService接口(Executor的子接口)的实现类都是线程池，可以分为三大类

ForkJoinPool
ScheduledThreadPoolExecutor
ThreadPoolExecutor

具体的线程池，在工具类Executors中预创建了六小类

实现了ThreadPoolExecutor类：

ExecutorService newCachedThreadPool()：无界线程池
ExecutorService newFixedThreadPool()：有界线程池
ExecutorService newSingleThreadExecutor()：单一线程池

实现了ScheduledThreadPoolExecutor类：

ScheduledExecutorService newSingleThreadScheduledExecutor()
ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

实现了ForkJoinPool类：

ExecutorService newWorkStealingPool()

当然我们也可以自定义线程池

Executors类实践

线程类

public class TaskTest implements Runnable {
    public void run(){
        try {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getId()+" is running");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

}

CachedThreadPool 无界线程池，最多可创建Integer.MAX_VALUE个线程，运行结果没有重复的线程号

public class ThreadPoolExecutor1 {
    public static void main(String[] args){
        ExecutorService cachedThreadPool= Executors.newCachedThreadPool();

        for(int i=0;i<10;i++){
            cachedThreadPool.execute(new TaskTest());
        }
    }
}

运行结果

FixedThreadPool 固定线程数线程池

public class ThreadPoolExecutor1 {
    public static void main(String[] args){
        ExecutorService cachedThreadPool= Executors.newFixedThreadPool(2);

        for(int i=0;i<10;i++){
            cachedThreadPool.execute(new TaskTest());
        }
    }
}

2个线程执行10个任务

执行结果

SingleThreadExecutor 单一线程执行任务

public class ThreadPoolExecutor1 {
    public static void main(String[] args){
        ExecutorService cachedThreadPool= Executors.newSingleThreadExecutor();

        for(int i=0;i<10;i++){
            cachedThreadPool.execute(new TaskTest());
        }
    }
}

运行结果

三种线程池(返回ThreadPoolExecutor)构造方法

以下3种线程池均实现了ThreadPoolExecutor类

public static ExecutorService newCachedThreadPool() {
     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());}

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

ThreadPoolExecutor中的成员变量
以上3中线程池都是使用了ThreadPoolExecutor中的一种构造方法：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
                     long keepAliveTime, TimeUnit unit, 
                        BlockingQueue<Runnable> workQueue)

三种线程池(返回ThreadPoolExecutor类)分析
newCachedThreadPool：核心线程数为0，最大线程数为Integer.MAX_VALUE，所以称之为无界线程池；假设一次执行20个任务，由于corePoolSize为0，所以20个任务全会进入阻塞队列BlockingQueue，启动新线程执行队列中的任务，最多可以启动20个任务，如果20个任务都执行完毕，从线程闲置时开始倒计时60s，超时则关闭线程。

FixedThreadPool：因为核心线程数是传入且固定的，所以称为有界线程池，一般在后台执行一些辅助性的任务，最大线程数与核心线程数相等；假设核心线程数为3，一次执行20个任务：先启动3个线程，剩下17个任务会进入BlockingQueue排队；因为核心线程数数=最大线程数，所以keepAliveTime这个参数是没有意义的。

SingleThreadExecutor：线程池中只有1个线程，超过1个任务进入阻塞队列，与FixedThreadPool类似，只不过nThread=1。比如说服务端需要有一个线程不断监听客户端发送来的socket，一旦出现异常会新建一个线程来替换。

execute与submit方法
Executor接口中有一个方法

而其子接口ExecutorService中有3个重载的submit方法

submit是基方法Executor.execute(Runnable)的延伸，通过创建并返回一个Future类对象可用于取消执行和/或等待完成。

Future类中的方法

用submit方法举个例子，获取多线程运行结果


import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
 
 
public class test {
	public static void main(String[] args) {
		ExecutorService exec = Executors.newCachedThreadPool();
		for(int i=0;i<20;i++){
			Future<String> f = exec.submit(new TaskResult(i));
			try {
				String v=f.get();
				System.out.println(v);
			} catch (Exception e) {
			}
		}
	}
}
 
class TaskResult implements Callable<String>{
	private int i;
	public TaskResult(int i){
		this.i=i;
	}
	public String call(){
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return Thread.currentThread().getId()+"'s result is "+i;
	}
}

运行结果，这是execute方法无法实现的

ThreadPoolExecutor类源码分析

ThreadPoolExecutor是线程池的核心类，是线程池的具体实现，看源码可知，此类有4个构造方法，其中前三个都是依赖最后一个构造方法。

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }  

  

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }    

    

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

分析其中的参数：

corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
```
ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;
```
ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

threadFactory：线程工厂，主要用来创建线程；

RejectedExecutionHandler handler 拒绝策略

undefined

拒绝策略

拒绝行为

AbortPolicy

抛出RejectedExecutionException

DiscardPolicy

什么也不做，直接忽略

DiscardOldestPolicy

丢弃执行队列中最老的任务，尝试为当前提交的任务腾出位置

CallerRunsPolicy

直接由提交任务者执行这个任务

分析线程池中最重要的方法---execute的实现

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

执行逻辑为

1.如果正在运行少于corePoolSize的线程，尝试使用给定命令启动新线程。调用addWorker时会以原子方式检查runState和workerCount，通过返回false来防止在不应该添加线程时添加线程。

2.如果任务可以成功进入队列，那么我们仍然需要仔细检查是否应该添加一个线程（因为自上次检查后现有的线程已经死亡），或者自从进入此方法后池关闭了。所以我们重新检查状态，如果线程停止了那么将任务回滚进入其他线程，或者如果没有其他线程，则启动新的线程。

3.如果我们不能将任务入队，那么我们尝试添加一个新线程。如果失败，我们知道我们已关闭或饱和，因此拒绝该任务。

workQueue是一个BlockingQueue，也就是说当前线程数小于corePoolSize，那么就启用新的线程，如果大于corePoolSize（如果有扩容机制，那么就是maximumPoolSize），那么就放到这个workQueue里面（workQueue.offer）

分析线程池类的组成与实现

Executor ：
Executor 它是”执行者”接口，它是来执行任务的。准确的说，Executor提供了execute()接口来执行已提交的Runnable 任务的对象。Executor存在的目的是提供一种将”任务提交”与”任务如何运行”分离开来的机制。它只包含一个函数接口：void execute(Runnable command)

ExecutorService：
ExecutorService继承于Executor。它是”执行者服务”接口，它是为”执行者接口Executor”服务而存在的；准确的话，ExecutorService提供了”将任务提交给执行者的接口(submit方法)”，”让执行者执行任务(invokeAll,

AbstractExecutorService
AbstractExecutorService是一个抽象类，它实现了ExecutorService接口。
AbstractExecutorService存在的目的是为ExecutorService中的函数接口提供了默认实现。

ThreadPoolExecutor：
ThreadPoolExecutor就是大名鼎鼎的”线程池”。它继承于AbstractExecutorService抽象类。

ScheduledExecutorService：
ScheduledExecutorService是一个接口，它继承于于ExecutorService。它相当于提供了”延时”和”周期执行”功能的ExecutorService。
ScheduledExecutorService提供了相应的函数接口，可以安排任务在给定的延迟后执行，也可以让任务周期的执行。

ScheduledThreadPoolExecutor：
ScheduledThreadPoolExecutor继承于ThreadPoolExecutor，并且实现了ScheduledExecutorService接口。它相当于提供了”延时”和”周期执行”功能的ScheduledExecutorService。
ScheduledThreadPoolExecutor类似于Timer，但是在高并发程序中，ScheduledThreadPoolExecutor的性能要优于Timer。

Executors：
Executors是个静态工厂类。它通过静态工厂方法返回ExecutorService、ScheduledExecutorService、ThreadFactory和 Callable

1、newCachedThreadPool

作用：创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们，并在需要时使用提供的 ThreadFactory 创建新线程。

特征：
（1）线程池中数量没有固定，可达到最大值（Interger. MAX_VALUE）
（2）线程池中的线程可进行缓存重复利用和回收（回收默认时间为1分钟）
（3）当线程池中，没有可用线程，会重新创建一个线程

创建方式： Executors.newCachedThreadPool();

2、newFixedThreadPool

作用：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。

特征：
（1）线程池中的线程处于一定的量，可以很好的控制线程的并发量
（2）线程可以重复被使用，在显示关闭之前，都将一直存在
（3）超出一定量的线程被提交时候需在队列中等待

创建方式：
（1）Executors.newFixedThreadPool(int nThreads)；//nThreads为线程的数量
（2）Executors.newFixedThreadPool(int nThreads，ThreadFactory threadFactory)；//nThreads为线程的数量，threadFactory创建线程的工厂方式

3、newSingleThreadExecutor

作用：创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool(1) 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

特征：
（1）线程池中最多执行1个线程，之后提交的线程活动将会排在队列中以此执行

创建方式：
（1）Executors.newSingleThreadExecutor() ；
（2）Executors.newSingleThreadExecutor(ThreadFactory threadFactory)；// threadFactory创建线程的工厂方式

4、newScheduleThreadPool

作用：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

特征：
（1）线程池中具有指定数量的线程，即便是空线程也将保留
（2）可定时或者延迟执行线程活动

创建方式：
（1）Executors.newScheduledThreadPool(int corePoolSize)；// corePoolSize线程的个数
（2）newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)；// corePoolSize线程的个数，threadFactory创建线程的工厂

5、newSingleThreadScheduledExecutor

作用：创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。

特征：
（1）线程池中最多执行1个线程，之后提交的线程活动将会排在队列中以此执行
（2）可定时或者延迟执行线程活动

创建方式：
（1）Executors.newSingleThreadScheduledExecutor() ；
（2）Executors.newSingleThreadScheduledExecutor(ThreadFactory threadFactory) ；//threadFactory创建线程的工厂