互联网架构（3）：并发编程--线程池_互联网线程池应用-优快云博客

本文链接：https://blog.youkuaiyun.com/a314368439/article/details/72640788

本文详细介绍了Java Executor框架的核心概念及使用方法，包括四种不同类型的线程池：固定线程池、单一线程池、缓存线程池和定时线程池。此外，还讲解了如何自定义线程池，并探讨了不同队列类型的选择及其对线程池行为的影响。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

3 Executor框架

为了更好的控制多线程，JDK提供了一套线程框架Executor，帮助开发人员有效的进行线程控制。它们都在java.util.concurrent包中，是JDK并发包的核心。其中有一个比较重要的类:Executors，它扮演着线程工厂的角色，我们通过Executors可以创建特定功能的线程池。

（1） JDK提供的线程池

Executors创建线程池的方法：

newFixedThreadPool()方法，该方法返回一个固定数量的线程池，该方法的线程数始终不变，当有一个任务提交时，若线程池中空闲，则立即执行，若没有，则会被暂缓在一个任务队列中，等待有空闲的线程去执行。
newSingleThreadExecutor()方法，创建一个线程的线程池，若空闲则执行，若没有空闲线程，则暂缓在任务队列中
newCachedThreadPool()方法，该方法返回一个可根据实际情况调整线程个数的线程池，不限制最大线程数量，若有空闲的线程则用空闲的线程执行任务，否则创建一个新的线程，若无任务则不创建线程。并且每一个空闲线程会在60秒后自动回收
newScheduledThreadPool()方法，该方法返回一个SchededExecutorService对象，但该线程池可以指定线程的数量,类似于定时器，可以做定时轮询。

若Executors工厂类无法满足我们的需求，可以自己去创建自定义的线程池，其实Executors工厂类里面的创建线程方法其内部实现均是用了ThreadPoolExecutor这个类，这个类可以自定义线程池。构造方法如下

     public ThreadPoolExecutor(int corePoolSize, //核心线程数的大小（默认创建的线程个数）
                              int maximumPoolSize, //最大线程数
                              long keepAliveTime, //每个线程的空闲时间
                              TimeUnit unit, //空闲时间的时间单位
                              BlockingQueue<Runnable> workQueue,//线程缓冲队列
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {//拒绝执行时调用的方法

    }

提交线程到线程池有两种方法，submit和execute。两者有如下两个区别：
- 第一：submit可以提交Runnable或者是Callable接口的实现类，而execute则不行。
- 第二：submit有返回值，返回值为Future的接口实现类，而execute没有返回值。

（2）自定义线程池详解

使用什么类型的队列是关键
- 使用有界队列：若有新的任务需要执行，如果线程池实际线程数小于corePoolSize则优先创建线程，若大于corePoolSize，则会将任务加入队列，若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程数，若线程数大于maximumPoolSize，则执行拒绝策略，或其他自定义方式。
- 使用无界队列： LinkedBlockQueue。与有界队列相比，除非系统资源消耗尽，否则无界的任务队列不存在入队失败的情况。当有新任务到来，系统的线程数小于corePoolSize时，则创建新线程执行任务。当到达corePoolSize后，就不会继续增加。若后续任由新的任务加入，而又没有空闲的线程资源，则任务直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统内存。
JDK拒绝策略（属于ThreadPoolExecutor的内部静态类）
- AbortPolicy ：直接抛出异常，阻止系统正常工作
- CallerRunsPolicy ：只要线程池未关闭，该策略直接在调用者线程中，运行当前要被丢弃的任务。
- DiscardOldestPolicy ：丢弃最老的一个请求，尝试再次提交当前任务。
- DiscardPolicy ：丢弃无法处理的任务，不给予任何处理。

如果需要自定义拒绝策略，可以实现RejectedExecutionHandler接口,

自定义策略常见处理方式：（一般开发中在拒绝策略中仅仅只是记录日志即可）

1、通过某种方式，向请求源反馈拒绝提示（高峰期不建议采用，可能导致请求源一直提示错误）
2、记录日志，记录任务的关键信息，然后可以在非高峰期采取日志解析或者其他方式解析日志进行重新处理等
3、使用一种其他的方式缓存当前任务，之后再进行处理

MyTask.java

public class MyTask implements Runnable{

    private int taskId;
    private String taskName;

    public MyTask(int taskId, String taskName) {
        super();
        this.taskId = taskId;
        this.taskName = taskName;
    }

    public int getTaskId() {
        return taskId;
    }

    public void setTaskId(int taskId) {
        this.taskId = taskId;
    }

    public String getTaskName() {
        return taskName;
    }

    public void setTaskName(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {
            System.out.println(Thread.currentThread().getName() + " - run taskId = " + this.taskId);
            Thread.sleep(5 * 1000);
        } catch (Exception e) {
            // TODO: handle exception
        }
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return Integer.toString(this.taskId);
    }


}

MyRejected.java

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

public class MyRejected implements RejectedExecutionHandler{

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // TODO Auto-generated method stub
        System.out.println("自定义处理...");
        System.out.println("当前被拒绝的任务为：" + r.toString());
    }

}

UseThreadPoolExecutor2.java

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;SynchronousQueue
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class UseThreadPoolExecutor2 {

    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Runnable> queue =
//              new LinkedBlockingQueue<Runnable>();//使用无界队列
                new ArrayBlockingQueue<Runnable>(3);//使用有界队列
        ExecutorService pool = new ThreadPoolExecutor(
                1, 
                2, 
                120L, 
                TimeUnit.SECONDS, 
                queue,
//              new ThreadPoolExecutor.DiscardOldestPolicy());//jdk自带拒绝策略，丢弃最老的一个请求
                new MyRejected());//自定义拒绝策略

        for(int i = 1; i <= 20; i++){
            MyTask task = new MyTask(i, "任务" + i);
            pool.execute(task);
        }

        Thread.sleep(1000);
        System.out.println("queue size : " + queue.size());
        Thread.sleep(2000);

    }

}