线程池 Executors

原创已于 2022-04-03 15:48:57 修改 · 120 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

于 2021-07-29 19:59:41 首次发布

面向对象进阶同时被 3 个专栏收录

11 篇文章

订阅专栏

核心类库

8 篇文章

订阅专栏

线程

4 篇文章

订阅专栏

本文详细介绍了Java中的线程池概念及其优势，包括降低资源消耗、提高响应速度和增强线程管理。文章通过实例演示了四种类型的线程池：缓存线程池、定长线程池、单线程线程池和周期性任务定长线程池的工作流程和应用场景。

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

线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

降低资源消耗。
提高响应速度。
提高线程的可管理性。

Java中的四种线程池 . ExecutorService

缓存线程池

 /**
     *  缓存线程池（长度无限制）
     *  任务加入后的执行流程：
     *      1.  判断线程消除是否存在空闲线程
     *      2.  存在则使用
     *      3.  不存在， 则创建线程并放入线程池，然后使用
     */
    public static void main(String[] args) {
        //向线程池中加入新的任务
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "小明的任务！");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "小明的任务！");
            }
        });
        try {//只两个线程会被使用，注释try catch语句五个使用
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "小明的任务！");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "小明的任务！");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "小明的任务！");
            }
        });
    }

定长线程池

/**
     * 定长(指定线程数量)线程池.（长度为指定的数值）
     * 任务加入后的执行流程：
     *      1.  判断线程池是否存在空闲线程
     *      2.  存在则使用
     *      3.  不存在空闲线程，且线程池末满的情况下，则创建线程并放入线程池，然后使用
     *      4.  不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "小黑的任务");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "小黑的任务");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "小黑的任务");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

单线程线程池

 /**
     * 单线程线程池(效果与定长线程池 创建时传入数值1效果一致.)
     * 执行流程：
     *      1.  判断线程池里的那个线程是否空闲
     *      2.  空闲则使用
     *      3.  不空闲则等待 等池中的那个单个线程空闲后再使用
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "床前明月光");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "疑是地上霜");
            }
        });
    }

周期性任务定长线程池

/**
     * 周期（可以周期执行任务）定长线程池
     *      1.  判断线程池是否存在空闲线程
     *      2.  存在则使用
     *      3.  不存在空闲线程，且线程池末满的情况下，则创建线程 并放入线程池
     *      4.  不存在空闲线程，且线程已满的情况下，则等待线程池存在空闲线程
     *
     * 周期性任务执行时：
     *      定时执行， 当某个时机触发时，自动执行某任务
     */
    public static void main(String[] args) {
        //ScheduleExecutorService是 ExecutorService的子类
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 1.   定时执行一次
         * 参数1.定时执行的任务
         * 参娄2.时长数字
         * 参数3.时长数字的时间单位， TimeUnit的常量指定
         */
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("小明的任务");
            }
        }, 3 , TimeUnit.SECONDS);

        /**
         * 周期性执行任务
         * 参数1. 任务
         * 参数2. 延迟时长的数字（initialDelay初始时延：初始时延之后执行第一次）
         * 参数3. 周期时长数字（每隔多久执行一次）
         * 参数4. 时长数字的单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("小黑的任务");
            }
        }, 5, 2, TimeUnit.SECONDS);
    }