线程池简介

快乐的小三菊

已于 2023-10-26 15:22:17 修改

阅读量266

点赞数

分类专栏：多线程文章标签： java

于 2017-12-17 20:37:46 首次发布

本文链接：https://blog.csdn.net/xhf852963/article/details/78827673

版权

多线程专栏收录该内容

9 篇文章 0 订阅

订阅专栏

一、概念

线程池就是一个复用线程的技术。

如果不使用线程池，那么用户每发起一个请求，后台就需要创建一个新线程处理，下次新任务来了肯定又要创建新线程处理的，而创建线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能。

二、创建线程池的方式

JDK1.5 起提供了代表线程池的接口：ExecutorService

2.1 获取线程池对象

方式一：使用 ExecutorService 的实现类 ThreadPoolExecutor 自创建一个线程池对象。

方式二：使用 Executors （线程池工具类）调用方法返回不同特点的线程池对象。

2.2 ThreadPoolExecutor 构造器

# 指定线程池的核心线程的数量
corePoolSize

# 指定线程池的最大线程数量
maximumPoolSize

# 指定临时线程的存活时间，假设核心线程数量为 3，最大线程数量为 5，那么临时线程数量就是 2
# 那么临时线程的存活时间说的就是这2个线程的存活时间
keepAliveTime

# 指定临时线程的存活时间单位（秒、分、时、天）
unit

# 指定线程池的任务队列
workQueue

# 指定线程池的线程工厂
threadFactory

# 指定线程池的任务拒绝策略（线程都在忙且任务队列也满了的时候，新任务来了该如何出来）
handler

2.3 代码举例

public class ThreadPool {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
    }
}

2.4 注意事项

2.4.1 临时线程何时创建

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

2.4.2 何时开始拒绝新任务

核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会拒绝任务。

三、线程池处理 Runnable 任务

3.1 常用方法

方法名称	说明
void execute(Runnable command)	执行 Runnable 任务
Future<T> submit(Callable<T> task)	执行 Callable 任务，返回未来任务对象，用于获取线程返回的结果
void shutdown()	等全部任务执行完毕后，再关闭线程池。
List<Runnable> shutdownNow()	立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

3.2 代码演练

首先创建一个任务类，代码如下所示：

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        String name =Thread.currentThread().getName();
        try {
            System.out.println(name+"输出~~~~~");
            Thread.sleep(1000l);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试的代码如下所示：

public class ThreadPool {
    public static void main(String[] args) {
        // 创建一个线程池对象，核心线程数是3个，最大线程数是5个，即支持创建出2个临时线程出来
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        Runnable target = new MyRunnable();
        pool.execute(target);// 线程池会自动创建一个新线程，自动处理这个任务，自动执行。
        pool.execute(target);// 线程池会自动创建一个新线程，自动处理这个任务，自动执行。
        pool.execute(target);// 线程池会自动创建一个新线程，自动处理这个任务，自动执行。
        pool.execute(target);// 复用前面的核心线程来处理这个任务
        pool.execute(target);// 复用前面的核心线程来处理这个任务
    }
}

输出结果如下所示，可以发现确实是复用了前面的核心线程，但是我们发现此时的程序是没有死亡的，因为线程池是不会死亡的，线程池里面的线程是要长久存活为我们服务的。

如果想让线程池死亡有两种方式，第一种是手动结束掉；第二种是调用上面提到的 shutdown() 方法或者 shutdownNow() 方法。

3.3 创建临时线程

为了复现出创建临时线程的场景，我们需要修改上面的代码，延长线程阻塞的时间，如下所示：

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        String name =Thread.currentThread().getName();
        try {
            System.out.println(name+"输出~~~~~");
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

创建临时线程的时机为：3 个核心线程在忙，任务队列占满了，此时再出现新任务时就会创建我们的临时线程。

public class ThreadPool {
    public static void main(String[] args) {
        // 创建一个线程池对象，核心线程数是3个，最大线程数是5个，即支持创建出2个临时线程出来
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        Runnable target = new MyRunnable();
        pool.execute(target);// 线程池会自动创建一个新线程，自动处理这个任务，自动执行。
        pool.execute(target);// 线程池会自动创建一个新线程，自动处理这个任务，自动执行。
        pool.execute(target);// 线程池会自动创建一个新线程，自动处理这个任务，自动执行。

        pool.execute(target);// 排队
        pool.execute(target);// 排队
        pool.execute(target);// 排队
        pool.execute(target);// 排队

        pool.execute(target);// 到了临时线程创建的时机了
        pool.execute(target);// 
    }
}

3.4 拒绝策略

ThreadPoolExecutor 构造器的最后一个参数为拒绝的策略，当核心线程正在忙，阻塞队列了满了，临时线程也正在忙，此时再有任务进来，就会触发拒绝策略，拒绝策略有哪些呢？如下：

策略	详解
ThreadPoolExecutor.AbortPolicy	丢弃任务并抛出异常，是默认的策略
ThreadPoolExecutor.DiscardPolicy	丢弃任务但不抛出异常，不推荐这种
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务，然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	由主线程负责调用任务中的 run() 方法从而绕过线程池直接执行

接下来我们测试下默认的这种策略，代码如下：

public class ThreadPool {
    public static void main(String[] args) {
        // 创建一个线程池对象，核心线程数是3个，最大线程数是5个，即支持创建出2个临时线程出来
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        Runnable target = new MyRunnable();
        pool.execute(target);// 线程池会自动创建一个新线程，自动处理这个任务，自动执行。
        pool.execute(target);// 线程池会自动创建一个新线程，自动处理这个任务，自动执行。
        pool.execute(target);// 线程池会自动创建一个新线程，自动处理这个任务，自动执行。

        pool.execute(target);// 排队
        pool.execute(target);// 排队
        pool.execute(target);// 排队
        pool.execute(target);// 排队

        pool.execute(target);// 到了临时线程创建的时机了
        pool.execute(target);// 到了临时线程创建的时机了

        pool.execute(target);// 到了临时线程拒绝的时机了
    }
}

四、线程池处理 Callable 任务

4.1 代码演练

首先创建一个任务类，代码如下所示：

public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n){
        this.n = n;
    }
    @Override
    public String call() throws Exception {
        int sum = 0;
        for(int i=1;i<=n;i++){
            sum += i;
        }
        return Thread.currentThread().getName()+"线程求出了 1-"+n+"的和为："+sum;
    }
}

测试的代码如下所示：

public class ThreadPoolCallable {
    public static void main(String[] args) throws Exception{
        // 创建一个线程池对象，核心线程数是3个，最大线程数是5个，即支持创建出2个临时线程出来
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());

        // 使用线程处理 Callable 任务
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());

    }
}

输出结果如下所示：

五、Executors 工具类实现线程池

5.1 简介

Executors 是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。

5.2 分类

下面的这些方法的底层，都是通过线程池的实现类 ThreadPoolExecutor 创建的线程池对象。

方法名称	说明
public static ExecutorService newFixedThreadPool (int nThreads)	创建固定数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新的线程代替它
public static ExecutorService newSingleThreadExecutor()	创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新的线程
public static ExecutorService newCachedThreadPool()	线程数量随着任务增加而增加，如果线程执行任务完毕且空闲了 60s 则会被回收掉
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务或者定期执行任务。

5.3 代码演练

public class ThreadPoolCallable {
    public static void main(String[] args) throws Exception{
        // 固定大小的线程池
        ExecutorService pool1 = Executors.newFixedThreadPool(4);
        // 单例线程池
        ExecutorService pool2 = Executors.newSingleThreadExecutor();
        // 缓存线程池
        ExecutorService pool3 = Executors.newCachedThreadPool();
        // 延时任务线程池
        ScheduledExecutorService pool4 = Executors.newScheduledThreadPool(4);

        // 使用线程处理 Callable 任务
        Future<String> f1 = pool1.submit(new MyCallable(100));
        Future<String> f2 = pool2.submit(new MyCallable(200));
        Future<String> f3 = pool3.submit(new MyCallable(300));
        Future<String> f4 = pool4.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}