juc-12-线程池2-线程池的使用

最新推荐文章于 2022-10-07 16:27:59 发布

黑桃SevenPig

最新推荐文章于 2022-10-07 16:27:59 发布

阅读量340

点赞数

分类专栏： 002-juc 文章标签： java 线程池

本文链接：https://blog.csdn.net/qq_20633779/article/details/110457401

版权

这是线程池第二篇文章，上一篇文章写了如何创建线程池，这篇文章用代码来演示通过 ThreadPoolExecutor 和 Executors的静态工厂方法创建线程池，以及这些线程池的基本使用，然后重点讲解 ThreadPoolExecutor 的实现接口 ExecutorService 中的常用API，如何通过这些API来管理线程池。

1、ThreadPoolExecutor 创建线程池

从上篇文章《juc-12-线程池2-线程池的使用》中，我们学习到 ThreadPoolExecutor 几个重载的构造函数都会调用下面这个构造函数：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
这个构造函数指定 corePoolSize、maximumPoolSize、keepAliveTime 、workQueue、threadFactory 和 RejectedExecutionHandler

其他重载的构造函数中：

如果没有指定线程工厂threadFactory，则默认使用Executors.defaultThreadFactory()；
如果没有指定拒绝策略 RejectedExecutionHandler，则默认使用 AbortPolicy，表示直接抛出异常。

提示： BlockingQueue阻塞队列的相关知识点，请看前面的文章《juc-10-阻塞队列》。

添加线程的规则：

如果线程小于corePoolSize的时候，即使线程有处于空闲状态，也会继续创建新的线程运行新的任务
如果等于大于corePoolSize，但是小于maxPoolSize，则将任务放入队列
如果队列已满，并且线程数小于maxPoolSize，创建新的线程来运行人任务。
如果队列已满，并且线程数大于或者等于maxPoolSize，则拒绝该任务，拒绝策略由 RejectedExecutionHandler决定。

演示 ThreadPoolExecutor 创建线程池

public class ThreadPoolExecutorDemo {

    public static void main(String[] args) {

        int corePoolSize = 3;//核心线程数=3，
        int maximumPoolSize = 5;//最大线程数=5
        int keepAliveTime = 30;//超出核心线程数的线程空闲时间超过 30ms 就会被回收
        int capacity = 10;//阻塞队列的容量=10
        ArrayBlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(capacity);
        // 创建线程池，
        // 没有指定线程工厂threadFactory，则默认使用Executors.defaultThreadFactory()
        // 没有指定拒绝策略 RejectedExecutionHandler，则默认使用 AbortPolicy，表示直接抛出异常
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, workQueue);

        // 下面演示 taskCount 为同数值时的场景

        // 1. 任务数 <= corePoolSize + capacity，线程池中只有 corePoolSize 个线程
        // int taskCount = corePoolSize + capacity;

        // 2. corePoolSize + capacity < 任务数 <= maximumPoolSize + capacity，这时 corePoolSize < 线程池中线程数 <= maximumPoolSize
        // int taskCount = maximumPoolSize + capacity;

        // 3. 任务数 > maximumPoolSize + capacity , 线程池无法接受你所提交的任务的时候，采取的拒绝策略
        int taskCount = maximumPoolSize + capacity + 1;
        // 模拟程序需要执行 taskCount 个任务
        for (int i = 0; i < taskCount; i++) {
            // 每个任务启动一条线程去处理
            int index = i;
            // 给线程池提交任务
            threadPoolExecutor.submit(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "执行任务..." + index);
                    TimeUnit.MILLISECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        threadPoolExecutor.shutdown();//关闭线程池
    }
}

任务数 taskCount<= corePoolSize + capacity，运行结果如下：
此时，线程池中只有 corePoolSize 个线程，因为任务数量可以被 corePoolSize 个线程和 workQueue 所接受，线程数没有大于corePoolSize，所以线程执行完一个任务后，会通过 workQueue.take() 取出一个新任务继续执行。

pool-1-thread-1执行任务...0
pool-1-thread-3执行任务...2
pool-1-thread-2执行任务...1
pool-1-thread-1执行任务...3
pool-1-thread-2执行任务...4
pool-1-thread-3执行任务...5
pool-1-thread-1执行任务...6
pool-1-thread-3执行任务...8
pool-1-thread-2执行任务...7
pool-1-thread-2执行任务...9
pool-1-thread-1执行任务...10
pool-1-thread-3执行任务...11
pool-1-thread-2执行任务...12

corePoolSize + capacity < 任务数 taskCount <= maximumPoolSize + capacity，运行结果如下：
这时 corePoolSize < 线程池中线程数 <= maximumPoolSize，可以看出线程池中最多出现了5条线程执行任务。线程数大于corePoolSize，所以线程执行完一个任务后，会通过 workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) 取出一个新任务继续执行。

pool-1-thread-2执行任务...1
pool-1-thread-4执行任务...13
pool-1-thread-5执行任务...14
pool-1-thread-3执行任务...2
pool-1-thread-1执行任务...0
pool-1-thread-3执行任务...3
pool-1-thread-4执行任务...4
pool-1-thread-5执行任务...7
pool-1-thread-1执行任务...6
pool-1-thread-2执行任务...5
pool-1-thread-3执行任务...8
pool-1-thread-4执行任务...10
pool-1-thread-2执行任务...9
pool-1-thread-1执行任务...12
pool-1-thread-5执行任务...11

任务数 taskCount > maximumPoolSize + capacity , 运行结果如下：
线程池无法接受你所提交的任务的时候，采取的拒绝策略

pool-1-thread-1执行任务...0
pool-1-thread-5执行任务...14
pool-1-thread-3执行任务...2
pool-1-thread-4执行任务...13
pool-1-thread-2执行任务...1
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@568db2f2 rejected from java.util.concurrent.ThreadPoolExecutor@378bf509[Running, pool size = 5, active threads = 5, queued tasks = 10, completed tasks = 0]
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
	at java.util.concurrent.AbstractExecutorService.submit(AbstractExecutorService.java:112)
	at com.xander.juc._11threadPool.ThreadPoolExecutorDemo.main(ThreadPoolExecutorDemo.java:42)
pool-1-thread-2执行任务...4
pool-1-thread-4执行任务...3
...

2、Executors 创建线程池

2.1 Executors.newFixedThreadPool

newFixedThreadPool(int nThreads) ：用于创建固定线程数的线程池。

演示 newFixedThreadPool 的使用

public class NewFixedThreadPoolDemo {

    public static void main(String[] args) {
        // 创建固定5个线程的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        // 模拟程序需要执行1000个任务
        for (int i = 0; i < 1000; i++) {
            // 每个任务启动一条线程去处理
            int index = i;
            // 给线程池提交任务
            executorService.submit(()->{
                System.out.println(Thread.currentThread().getName() + "执行任务..."+ index);
            });
        }
        executorService.shutdown();//关闭线程池
    }
}

运行结果如下：
从线程名称可以看出，线程池中只有5条线程用于执行任务。

pool-1-thread-3执行任务...2
pool-1-thread-5执行任务...4
pool-1-thread-3执行任务...5
pool-1-thread-2执行任务...1
pool-1-thread-1执行任务...0
pool-1-thread-1执行任务...9
...
pool-1-thread-4执行任务...998
pool-1-thread-4执行任务...999
pool-1-thread-5执行任务...993
pool-1-thread-1执行任务...992
pool-1-thread-3执行任务...920
pool-1-thread-2执行任务...919

2.2 Executors.newSingleThreadExecutor

newSingleThreadExecutor() ：用于创建只有一条线程的线程池。

public class NewSingleThreadExecutorDemo {

    public static void main(String[] args) {
        // 创建只有一条线程的线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        // 模拟程序需要执行1000个任务
        for (int i = 0; i < 1000; i++) {
            // 每个任务启动一条线程去处理
            int index = i;
            // 给线程池提交任务
            executorService.submit(()->{
                System.out.println(Thread.currentThread().getName() + "执行任务..."+ index);
            });
        }
        executorService.shutdown();//关闭线程池
    }
}

运行结果如下：
从线程名称可以看出，线程池中只有1条线程用于执行任务。

pool-1-thread-1执行任务...0
pool-1-thread-1执行任务...1
pool-1-thread-1执行任务...2
pool-1-thread-1执行任务...3
...
pool-1-thread-1执行任务...996
pool-1-thread-1执行任务...997
pool-1-thread-1执行任务...998
pool-1-thread-1执行任务...999

2.3 Executors.newCachedThreadPool

newCachedThreadPool() ：创建无界线程池，maximumPoolSize = Integer.MAX_VALUE 近似无界，具有自动回收多余线程的功能。

corePoolSize = 0 说明核心线程数为0，
maximumPoolSize = Integer.MAX_VALUE，最大可创建

最低0.47元/天解锁文章

黑桃SevenPig

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
juc-12-线程池2-线程池的使用

这是线程池第二篇文章，上一篇文章写了如何创建线程池，这篇文章用代码来演示通过 ThreadPoolExecutor 和 Executors的静态工厂方法创建线程池，以及这些线程池的基本使用，然后重点讲解 ThreadPoolExecutor 的实现接口 ExecutorService 中的常用API，如何通过这些API来管理线程池。1、ThreadPoolExecutor 创建线程池从上篇文章《juc-12-线程池2-线程池的使用》中，我们学习到 ThreadPoolExecutor 几个重载的构造
复制链接

扫一扫