服务器接受大量请求时，使用线程池技术是非常合适的，它可以大大减少线程的创建和销毁次数，提高服务器的工作效率，实际在开发中，如果需要创建 5 个以上的线程，那么就可以使用线程池来管理

1. 为什么要使用线程池

  • 反复创建线程开销大
  • 过多的线程会占用太多内存

2. 使用线程池的好处

  • 加快响应速度
  • 合理利用 CPU 和内存
  • 统一管理

3. 线程池构相关参数

参数名含义
corePoolSize核心线程数，线程池中保留的线程数，即使它们是空闲的也不会被终止，除非设置了 allowCoreThreadTimeOut
maximumPoolSize最大线程数
keepAliveTime保持存活时间，当线程数大于核心数时，这是多余的空闲线程在终止之前等待新任务的最大时间，如果设置了 allowCoreThreadTimeOut，则核心线程也会回收
unitkeepAliveTime 的时间单位
workQueue任务存储队列，用于在任务执行之前保存它们的队列，这个队列将只保存由 execute 方法提交的 Runnable 任务
threadFactory线程工厂，执行程序创建新线程时要使用的工厂
handle拒绝策略，当执行因达到线程边界和队列容量而阻塞时要使用的处理程序
3.1 workQueue
  • 直接交换（SynchronousQueue）：不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于 LinkedBlockingQuene
  • 无界队列（LinkedBlockingQueue）：基于链表结构的无界阻塞队列，按 FIFO 排序任务，吞吐量通常要高于 ArrayBlockingQuene
  • 有界队列（ArrayBlockingQueue）：基于数组结构的有界阻塞队列，按 FIFO 排序任务
3.2 threadFactory
  • DefaultThreadFactory（默认）：创建的线程拥有相同优先级、非守护线程、有线程名称
  • PrivilegedThreadFactory：在 defaultThreadFactory 的基础上，可以让运行在这个线程中的任务拥有和这个线程相同的访问控制和 ClassLoader
3.3 handle
  • AbortPolicy：直接抛出异常，默认策略
  • CallerRunsPolicy：用调用者所在的线程来执行任务
  • DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务
  • DiscardPolicy：直接丢弃任务

4. 添加线程的规则

  • 如果线程小于 corePoolSize，即使其他工作线程处于空闲状态，也会创建一个新线程来运行新任务
  • 如果线程等于（或大于）corePoolSize 但小于 maximumPoolSize，则将任务放入队列
  • 如果队列已满，并且线程数小于 maximumPoolSize，则创建一个新线程来运行任务
  • 如果队列已满，并且线程数大于或等于 maxPoolSize，则使用拒绝策略

5. 增减线程的特点

  • 通过设置 corePoolSize 和 maxPoolSize 相同，就可以创建固定大小的线程池
  • 线程池希望保持较少的线程数，并且只有在负载变得很大时才增加它
  • 通过设置 maxPoolSize 为很高的值，例如 Integer.MAX_VALUE，可以允许线程池容纳任意数量的并发任务
  • 只有队列填满时才创建多于 corePoolSize 的线程，所以如果使用的是无界队列（例如 LinkedBlockingQueue）那么线程数就不会超过 corePoolSize

6. 创建线程池方式

  • ThreadPoolExecutor：最原始的创建线程池的方式
  • newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待，由于传进去的 LinkedBlockingQueue 是没有容量上限的，所以当请求数越来越多，并且无法及时处理完毕的时候也就是请求堆积的时候，会容易造成占用大量的内存，可能会发生 OОM
  • newSingleThreadExecutor：创建单个线程数的线程池，即只创建唯一的工作者线程来执行任务，单工作线程最大的特点是可以保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的，和 newFixedThreadPool 的原理基本一样，只不过把线程数直接设置成了 1，所以这也会导致同样的问题，也就是当请求堆积的时候，可能会占用大量的内存
  • newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程，这里的弊端在于第二个参数 maximumPoolSize 被设置为了 Integer.MAX_VALUE，这可能会创建数量非常多的线程甚至导致 OOM
  • newScheduledThreadPool：创建一个定长的线程池，而且支持定时的以及周期性的任务执行
  • newSingleThreadScheduledExecutor：创建一个单线程的可以执行延迟任务的线程池
  • newWorkStealingPool：创建一个具有抢占式操作的线程池

7. 相关方法

  • execute：提交任务，交给线程池来执行
  • submit：提交任务，能够返回执行结果
  • getTaskCount：返回线程池已执行和未执行的任务总数
  • getCompletedTaskCount：已完成的任务数量
  • getPoolSize：线程池当前的线程数量
  • getActiveCount：线程池中正在执行任务的线程数量
  • shutdown：平滑的关闭 ExecutorService，当调用这个方法时，ExecutorService 会停止接受任何新的任务且等待已经提交的任务执行完成，当所有已经提交的任务执行完毕后将会关闭 ExecutorService
  • isShutdown：线程池是否关闭，当调用 shutdown() 方法后返回为true
  • isTerminated：判断线程池关闭后所有的任务是否都执行完了，所有提交的任务完成后返回为true
  • awaitTermination：两个参数，一个是 timeout 即超时时间，另一个是 unit 即时间单位，这个方法会使线程等待 timeout 时长，当超过 timeout 时间后，会监测 ExecutorService 是否已经关闭，若关闭则返回 true，否则返回 false
  • shutdownNow：强制关闭 ExecutorService，它将取消所有运行中的任务和在工作队列中等待的任务，这个方法返回一个 List 列表，列表中返回的是等待在工作队列中的任务

8. 线程池状态

Snipaste_20211114_222009.png

  • RUNNING：接受新任务并处理排队任务
  • SHUTDOWN：不接受新任务，但处理排队任务
  • STOP：不接受新任务，也不处理排队任务，并中断正在进行的任务
  • TIDYING：所有任务都已终止，workerCount 为 0 时，线程会转换到 TIDYING 状态，并将运行 terminate() 钩子方法
  • TERMINATED：terminate() 运行完成

9. 线程池调优

  • CPU 密集任务：N + 1
  • IO 密集任务：2N
  • 混合型任务：N * U * (1 + WT/ST)

N：CPU 核心数
U：期望 CPU 利用率
WT：线程等待时间
ST：线程运行时间
使用 jvisualvm 分析，点击抽样器，总时间-自用时间=线程等待时间，自用时间=线程运行时间

参考：https://www.javacodegeeks.com/2012/03/threading-stories-about-robust-thread.html

/**
 * A class that calculates the optimal thread pool boundaries. It takes the desired target utilization and the desired
 * work queue memory consumption as input and retuns thread count and work queue capacity.
 *
 * @author Niklas Schlimm
 */
public abstract class PoolSizeCalculator {

    /**
     * The sample queue size to calculate the size of a single {@link Runnable} element.
     */
    private final int SAMPLE_QUEUE_SIZE = 1000;

    /**
     * Accuracy of test run. It must finish within 20ms of the testTime otherwise we retry the test. This could be
     * configurable.
     */
    private final int EPSYLON = 20;

    /**
     * Control variable for the CPU time investigation.
     */
    private volatile boolean expired;

    /**
     * Time (millis) of the test run in the CPU time calculation.
     */
    private final long testtime = 3000;

    /**
     * Calculates the boundaries of a thread pool for a given {@link Runnable}.
     *
     * @param targetUtilization    the desired utilization of the CPUs (0 <= targetUtilization <= 1)
     * @param targetQueueSizeBytes the desired maximum work queue size of the thread pool (bytes)
     */
    protected void calculateBoundaries(BigDecimal targetUtilization, BigDecimal targetQueueSizeBytes) {
        calculateOptimalCapacity(targetQueueSizeBytes);
        Runnable task = creatTask();
        start(task);
        start(task); // warm up phase
        long cputime = getCurrentThreadCPUTime();
        start(task); // test intervall
        cputime = getCurrentThreadCPUTime() - cputime;
        long waittime = (testtime * 1000000) - cputime;
        calculateOptimalThreadCount(cputime, waittime, targetUtilization);
    }

    private void calculateOptimalCapacity(BigDecimal targetQueueSizeBytes) {
        long mem = calculateMemoryUsage();
        BigDecimal queueCapacity = targetQueueSizeBytes.divide(new BigDecimal(mem), RoundingMode.HALF_UP);
        System.out.println("Target queue memory usage (bytes): " + targetQueueSizeBytes);
        System.out.println("createTask() produced " + creatTask().getClass().getName() + " which took " + mem
                + " bytes in a queue");
        System.out.println("Formula: " + targetQueueSizeBytes + " / " + mem);
        System.out.println("* Recommended queue capacity (bytes): " + queueCapacity);
    }

    /**
     * Brian Goetz' optimal thread count formula, see 'Java Concurrency in Practice' (chapter 8.2)
     *
     * @param cpu               cpu time consumed by considered task
     * @param wait              wait time of considered task
     * @param targetUtilization target utilization of the system
     */
    private void calculateOptimalThreadCount(long cpu, long wait, BigDecimal targetUtilization) {
        BigDecimal waitTime = new BigDecimal(wait);
        BigDecimal computeTime = new BigDecimal(cpu);
        BigDecimal numberOfCPU = new BigDecimal(Runtime.getRuntime().availableProcessors());
        BigDecimal optimalthreadcount = numberOfCPU.multiply(targetUtilization).multiply(
                new BigDecimal(1).add(waitTime.divide(computeTime, RoundingMode.HALF_UP)));
        System.out.println("Number of CPU: " + numberOfCPU);
        System.out.println("Target utilization: " + targetUtilization);
        System.out.println("Elapsed time (nanos): " + (testtime * 1000000));
        System.out.println("Compute time (nanos): " + cpu);
        System.out.println("Wait time (nanos): " + wait);
        System.out.println("Formula: " + numberOfCPU + " * " + targetUtilization + " * (1 + " + waitTime + " / "
                + computeTime + ")");
        System.out.println("* Optimal thread count: " + optimalthreadcount);
    }

    /**
     * Runs the {@link Runnable} over a period defined in {@link #testtime}. Based on Heinz Kabbutz' ideas
     * (http://www.javaspecialists.eu/archive/Issue124.html).
     *
     * @param task the runnable under investigation
     */
    public void start(Runnable task) {
        long start = 0;
        int runs = 0;
        do {
            if (++runs > 5) {
                throw new IllegalStateException("Test not accurate");
            }
            expired = false;
            start = System.currentTimeMillis();
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                public void run() {
                    expired = true;
                }
            }, testtime);
            while (!expired) {
                task.run();
            }
            start = System.currentTimeMillis() - start;
            timer.cancel();
        } while (Math.abs(start - testtime) > EPSYLON);
        collectGarbage(3);
    }

    private void collectGarbage(int times) {
        for (int i = 0; i < times; i++) {
            System.gc();
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }

    /**
     * Calculates the memory usage of a single element in a work queue. Based on Heinz Kabbutz' ideas
     * (http://www.javaspecialists.eu/archive/Issue029.html).
     *
     * @return memory usage of a single {@link Runnable} element in the thread pools work queue
     */
    public long calculateMemoryUsage() {
        BlockingQueue<Runnable> queue = createWorkQueue();
        for (int i = 0; i < SAMPLE_QUEUE_SIZE; i++) {
            queue.add(creatTask());
        }
        long mem0 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        long mem1 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        queue = null;
        collectGarbage(15);
        mem0 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        queue = createWorkQueue();
        for (int i = 0; i < SAMPLE_QUEUE_SIZE; i++) {
            queue.add(creatTask());
        }
        collectGarbage(15);
        mem1 = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        return (mem1 - mem0) / SAMPLE_QUEUE_SIZE;
    }

    /**
     * Create your runnable task here.
     *
     * @return an instance of your runnable task under investigation
     */
    protected abstract Runnable creatTask();

    /**
     * Return an instance of the queue used in the thread pool.
     *
     * @return queue instance
     */
    protected abstract BlockingQueue<Runnable> createWorkQueue();

    /**
     * Calculate current cpu time. Various frameworks may be used here, depending on the operating system in use. (e.g.
     * http://www.hyperic.com/products/sigar). The more accurate the CPU time measurement, the more accurate the results
     * for thread count boundaries.
     *
     * @return current cpu time of current thread
     */
    protected abstract long getCurrentThreadCPUTime();
}

public class MyPoolSizeCalculator extends PoolSizeCalculator {

    public static void main(String[] args) {
        MyPoolSizeCalculator calculator = new MyPoolSizeCalculator();
        calculator.calculateBoundaries(
                // CPU 利用率
                new BigDecimal(1.0),
                // 阻塞队列占用的内存大小
                new BigDecimal(100000));
    }

    protected long getCurrentThreadCPUTime() {
        // 当前线程占用的总时间
        return ManagementFactory.getThreadMXBean().getCurrentThreadCpuTime();
    }

    protected Runnable creatTask() {
        return new AsynchronousTask();
    }

    protected BlockingQueue createWorkQueue() {
        return new LinkedBlockingQueue<>();
    }
}

class AsynchronousTask implements Runnable {

    @Override
    public void run() {
//        System.out.println(Thread.currentThread().getName());
    }
}

Target queue memory usage (bytes): 100000
createTask() produced ink.ckx.consurrency.threadPool.AsynchronousTask which took 40 bytes in a queue
Formula: 100000 / 40
* Recommended queue capacity (bytes): 2500
Number of CPU: 16
Target utilization: 1
Elapsed time (nanos): 3000000000
Compute time (nanos): 2968750000
Wait time (nanos): 31250000
Formula: 16 * 1 * (1 + 31250000 / 2968750000)
* Optimal thread count: 16

Q.E.D.

盛年不重来，一日难再晨。