线程池代码分析

分析线程池的源码之前，先要知道线程池的作用，以下这几点引用自《码出高效-Java开发手册》：

1、利用线程池管理并复用线程、控制最大并发数等。

2、实现任务线程队列缓存策略和拒绝机制。

3、实现某些与时间相关的功能，如定时执行、周期执行等。

4、隔离线程环境。比如，交易服务和搜索服务在同一台服务器上，分别开启两个线程池，交易线程的资源消耗明显要大；因此，通过配置独立的线程池 ，将较慢的交易服务与搜索服务隔离开，避免各服务线程相互影响。

 

那么自然我们使用线程池的目的也就很显然了：

1、线程是稀缺资源，不能频繁的创建。

2、解耦作用；线程的创建与执行完全分开，方便维护。

3、应当将其放入一个池子中，可以给其他任务进行复用。

在看线程池源码之前，一张图先大致记住下实线箭头表示extends  虚线箭头表示 implements：

JDK1.5之后推出了相关的线程池的API，我们常见的创建线程池的方式有以下几种：

1. Executors.newCachedThreadPool()：无限线程池。
2. Executors.newFixedThreadPool(nThreads)：创建固定大小的线程池。
3. Executors.newSingleThreadExecutor()：创建单个线程的线程池。

查看代码会发现，其实看这三种方式创建的源码就会发现，以上三种都是利用利用 ThreadPoolExecutor 类实现的。

我们学习线程池是如何创建线程的。首先从 ThreadPoolExecutor 构造方法讲起

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

这个核心参数的含义：

• corePoolSize 为线程池的基本大小。
• maximumPoolSize 为线程池最大线程大小。
• keepAliveTime 和 unit 则是线程空闲后的存活时间。
• workQueue 用于存放任务的阻塞队列。
• handler 当队列和最大线程池都满了之后的饱和策略(补充一下友好的拒绝策略：①保存到数据库进行削峰填谷，在空闲时再提取出来执行。②转向某个提示页面。③打印日志)。
• TimeUnit 表示时间单位，keepAliveTime的时间单位通常是TimeUnit.SECONDS

通常我们都是使用:  threadPool.execute(new Job());

我们先上手写一个简单的线程池：

第一步：建立一个TaskDemo的线程类

import java.util.concurrent.TimeUnit;

public class TaskDemo implements Runnable {
    @Override
    public void run() {
        System.out.println("当前线程名："+Thread.currentThread().getName()+"  is running "+ System.currentTimeMillis());
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

第二步：利用3种常见的线程池的API接口进行线程池的创建

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;

public class ScheduledDemo {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(5);
 //       ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
        for (int i = 0; i < 10; i++) {
            Runnable task = new TaskDemo();
            pool.execute(task);
        }
    }
}

执行结果为：时间相差5秒，创建固定大小的线程池。

当前线程名：pool-1-thread-2  is running 1612099650398
当前线程名：pool-1-thread-1  is running 1612099650398
当前线程名：pool-1-thread-3  is running 1612099650398
当前线程名：pool-1-thread-4  is running 1612099650398
当前线程名：pool-1-thread-5  is running 1612099650399
当前线程名：pool-1-thread-2  is running 1612099655399
当前线程名：pool-1-thread-1  is running 1612099655399
当前线程名：pool-1-thread-3  is running 1612099655400
当前线程名：pool-1-thread-4  is running 1612099655400
当前线程名：pool-1-thread-5  is running 1612099655400

看到线程池的执行就知道execute()这个函数很重要了。

在具体分析之前先了解下线程池中所定义的状态，这些状态都和线程的执行密切相关：

  

    private static final int RUNNING    = -1 << COUNT_BITS;

    private static final int SHUTDOWN   =  0 << COUNT_BITS;

    private static final int STOP       =  1 << COUNT_BITS;

    private static final int TIDYING    =  2 << COUNT_BITS;

    private static final int TERMINATED =  3 << COUNT_BITS;

private static final int COUNT_BITS = Integer.SIZE-3;

32位的Integer来表示状态: COUNT_BITS  29位线程数量   高3位是状态码

• RUNNING 

      (1)状态说明：自然是运行状态，指可以接受任务执行队列里的任务线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0

      (2)状态切换：线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0！

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

• SHUTDOWN 

      (1) 状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。

     (2) 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。

• STOP 

1. 状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
2. 状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP。

• TIDYING 

(1) 状态说明：当所有的任务已终止，任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。

(2) 状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。 当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。

• TERMINATED 终止状态，当执行 terminated() 后会更新为这个状态。

1. 状态说明：线程池彻底终止，就变成TERMINATED状态。 
2. 状态切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

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) {//当前线程数量小于 coreSize 时创建一个新的线程运行
            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);
}

 第一次写线程池，感觉有点混乱，最后补充下如何配置核心的几个参数，有一点是肯定的，线程池肯定是不是越大越好

通常我们是需要根据这批任务执行的性质来确定的。

• IO 密集型任务：由于线程并不是一直在运行，所以可以尽可能的多配置线程，比如 CPU 个数 * 2
• CPU 密集型任务（大量复杂的运算）应当分配较少的线程，比如 CPU 个数相当的大小。

当然这些都是经验值，最好的方式还是根据实际情况测试得出最佳配置。

 

最后请记住：

优雅的关闭线程池！

有运行任务自然也有关闭任务，从上面提到的 5 个状态就能看出如何来关闭线程池。

其实无非就是两个方法 shutdown()/shutdownNow()。

但他们有着重要的区别：

• shutdown() 执行后停止接受新任务，会把队列的任务执行完毕。
• shutdownNow() 也是停止接受新任务，但会中断所有的任务，将线程池状态变为 stop。

最后的最后：线程池不允许使用 Executors ，而是通过 ThreadPoolExecutor 的方式创建 ，这样的处理方式能更加明确线程池的运行规则，规避资源耗尽的风险。

在 ThreadPoolExecutor 中提供了四个公开的内部静态类
• AbortPolicy （默认）：丢弃任务并抛出 RejectedExecutionException 异常。
• DiscardPolicy ： 丢弃任务，但是不抛出异常 ， 这是不推荐的做法。
• DiscardOldestPolicy ： 抛弃队列中等待最久的任务 ， 然后把当前任务加入队
列中。
• CallerRunsPolicy ：调用任务的 run（）方法绕过线程池直接执行。
 

import java.util.concurrent.atomic.AtomicLong;

public class Task implements Runnable {
    private final AtomicLong count= new AtomicLong(0L);
    @Override
    public void run() {
        System.out.println("running  "+ count.getAndIncrement());
    }
}

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

public class UserThreadFactory implements ThreadFactory {
    private final String namePrefix;
    private final AtomicInteger nextId = new AtomicInteger(1);

    UserThreadFactory(String whatFeatureOfGroup) {
        namePrefix = "UserThreadFactory's "+whatFeatureOfGroup+" -Worker-";}

    @Override
    public Thread newThread(Runnable task){
            String name = namePrefix + nextId.getAndIncrement();
            Thread thread= new Thread(null,task,name,0);
            System.out.println(thread.getName());
            return thread;
    }
}

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

public class UserRejectHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("task rejected  "+ executor.toString());
    }
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class UserThreadPool {
    public static void main(String[] args ) {
        BlockingQueue queue = new LinkedBlockingQueue( 2 );
        UserThreadFactory fl = new UserThreadFactory ("第一号机房");
        UserThreadFactory f2 = new UserThreadFactory ("第一号机房");
        UserRejectHandler handler = new UserRejectHandler();
        ThreadPoolExecutor threadPoolFirst
                = new ThreadPoolExecutor(1,2,60 ,
                TimeUnit.SECONDS , queue , fl , handler);
        ThreadPoolExecutor threadPoolSecond
                = new ThreadPoolExecutor(1,2 , 60 ,
                TimeUnit . SECONDS , queue , f2 , handler) ;
        Runnable task= new Task();
        for (int i = 0; i < 200 ; i++) {
            threadPoolFirst.execute(task);
            threadPoolSecond.execute(task);
        }
    }
}

UserThreadFactory's 第一号机房 -Worker-1
UserThreadFactory's 第一号机房 -Worker-1
UserThreadFactory's 第一号机房 -Worker-2
UserThreadFactory's 第一号机房 -Worker-2
running  0
running  1
running  2
running  3
running  4
running  5
task rejected  java.util.concurrent.ThreadPoolExecutor@135fbaa4[Running, pool size = 2, active threads = 0, queued tasks = 0, completed tasks = 3]
task rejected  java.util.concurrent.ThreadPoolExecutor@45ee12a7[Running, pool size = 2, active threads = 0, queued tasks = 2, completed tasks = 3]

当任务被拒绝的时候，拒绝策略会打印出当前线程池的大小已经达到了
maximumPoolSize=2 ，且队列已满，完成的任务数提示已经有 1 个（最后一行）。

PS：以上部分引用自《码出高效-Java开发手册》，非商业用途，仅供学习。