简要介绍ThreadPoolExecutor的构造以及使用

最新推荐文章于 2024-05-21 19:43:07 发布

麻烦来杯Mojito

最新推荐文章于 2024-05-21 19:43:07 发布

阅读量729

点赞数

分类专栏： java 文章标签： thread 多线程 java 队列并发编程

本文链接：https://blog.csdn.net/weixin_43791268/article/details/107470461

版权

java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

ThreadPoolExecutor常用构造方法

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue);
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory);
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue,  RejectedExecutionHandler handler);
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

参数：

corePoolSize 线程池保留线程数
maximumPoolSize 最大线程数
keepAliveTime 空闲线程等待最长时间，超时销毁
unit 等待时间的时间单位
workQueue 线程等待队列
threadFactory 创建线程的工厂
handler 线程池拒绝线程任务时的处理，默认抛异常

示例代码

public class ThreadTest {

    public static void main(String[] args) {
        ThreadPoolExecutorFactoryBean factory = new ThreadPoolExecutorFactoryBean();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 4, 100, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(6), new PrintExecutor());
        PrintExecutor printExecutor = new PrintExecutor();
        for (int i = 0; i < 10; i++) {
            executor.execute(printExecutor);
        }
        executor.shutdown();
    }
}

class PrintExecutor implements Runnable, RejectedExecutionHandler {

    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "正在执行");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("线程总数超出等待队列以及最大线程数" + executor.getTaskCount());
    }
}

运行结果

线程pool-1-thread-1正在执行
线程pool-1-thread-3正在执行
线程pool-1-thread-2正在执行
线程pool-1-thread-4正在执行
线程pool-1-thread-1正在执行
线程pool-1-thread-4正在执行
线程pool-1-thread-2正在执行
线程pool-1-thread-3正在执行
线程pool-1-thread-3正在执行
线程pool-1-thread-1正在执行

这里一共调用了10次线程执行任务，由于maximumPoolSize为4，这里每次开启4个线程执行，其余线程会在队列中等待执行。

public class ThreadTest {

    public static void main(String[] args) {
        ThreadPoolExecutorFactoryBean factory = new ThreadPoolExecutorFactoryBean();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 10, 100, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(1), new PrintExecutor());
        PrintExecutor printExecutor = new PrintExecutor();
        for (int i = 0; i < 10; i++) {
            executor.execute(printExecutor);
        }
        executor.shutdown();
    }
}

class PrintExecutor implements Runnable, RejectedExecutionHandler {

    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "正在执行");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("线程总数超出等待队列以及最大线程数" + executor.getTaskCount());
    }
}

执行结果

线程pool-1-thread-2正在执行
线程pool-1-thread-4正在执行
线程pool-1-thread-3正在执行
线程pool-1-thread-1正在执行
线程pool-1-thread-6正在执行
线程pool-1-thread-5正在执行
线程pool-1-thread-7正在执行
线程pool-1-thread-8正在执行
线程pool-1-thread-9正在执行
线程pool-1-thread-10正在执行

这里corePoolSize为10，因此直接创建了10个线程执行任务，此时maximumPoolSize与workQueue不生效

public class ThreadTest {

    public static void main(String[] args) {
        ThreadPoolExecutorFactoryBean factory = new ThreadPoolExecutorFactoryBean();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 10, 100, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(10), new PrintExecutor());
        PrintExecutor printExecutor = new PrintExecutor();
        for (int i = 0; i < 10; i++) {
            executor.execute(printExecutor);
        }
        executor.shutdown();
    }
}

class PrintExecutor implements Runnable, RejectedExecutionHandler {

    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "正在执行");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("线程总数超出等待队列以及最大线程数" + executor.getTaskCount());
    }
}

执行结果

线程pool-1-thread-1正在执行
线程pool-1-thread-1正在执行
线程pool-1-thread-1正在执行
线程pool-1-thread-1正在执行
线程pool-1-thread-1正在执行
线程pool-1-thread-1正在执行
线程pool-1-thread-1正在执行
线程pool-1-thread-1正在执行
线程pool-1-thread-1正在执行
线程pool-1-thread-1正在执行

这里一共调用十次线程执行，corePoolSize为1，workQueue为10，等待队列足够大因此只会使用一个线程，此时maximumPoolSize无效

public class ThreadTest {

    public static void main(String[] args) {
        ThreadPoolExecutorFactoryBean factory = new ThreadPoolExecutorFactoryBean();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 5, 100, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), new PrintExecutor());
        PrintExecutor printExecutor = new PrintExecutor();
        for (int i = 0; i < 10; i++) {
            executor.execute(printExecutor);
        }
        executor.shutdown();
    }
}

class PrintExecutor implements Runnable, RejectedExecutionHandler {

    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "正在执行");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("线程总数超出等待队列以及最大线程数" + executor.getTaskCount());
    }
}

执行结果

线程pool-1-thread-2正在执行
线程pool-1-thread-3正在执行
线程pool-1-thread-1正在执行
线程pool-1-thread-5正在执行
线程pool-1-thread-4正在执行
线程总数超出等待队列以及最大线程数7
线程总数超出等待队列以及最大线程数7
线程总数超出等待队列以及最大线程数7
线程pool-1-thread-2正在执行
线程pool-1-thread-4正在执行

由于maximumPoolSize和workQueue加起来只有7个线程，其余线程则被拒绝，被拒绝的线程会调用线程拒绝执行处理器的rejectException方法

结论

核心线程数corePoolSize的值是多少，那么线程池最少就有多少个线程，即使线程都是空闲的。
当线程数量超过corePoolSize时，剩下的线程如果没有超过workQueue的容量，则剩下的线程会进入队列中等待核心线程执行完。
当线程数量超过corePoolSize与workQueue容量的总和，但剩下的部分没有超过maximumPoolSize时，会开启新的线程来执行剩下的线程。
当线程数量超过前三者之和时，剩余的线程会走RejectedExecutionHandler 的rejectedExecution方法，如果没有配置的话，这些线程会被拒绝执行，并抛出异常。
如果设置了allowCoreThreadTimeOut为true的话，即便空闲线程数量低于核心线程数也会在超时的时候销毁。

麻烦来杯Mojito

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
简要介绍ThreadPoolExecutor的构造以及使用

ThreadPoolExecutor常用构造方法public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)参数：corePoolSize 线程池保留线
复制链接

扫一扫