Java 线程池原理

为什么要用线程池

线程是不是越多越好?
1、线程在java中是一个对象,更是操作系统的资源,线程创建/销毁需要时间。如果创建时间+销毁时间 > 任务执行时间,就得不偿失了。
2、java对象占用堆内存,操作系统线程占用系统内存,根据JVM规范,一个线程默认最大栈大小1M,这个栈空间是需要从系统中分配的。线程过多,会消耗很多的内存。
3、操作系统需要频繁切换线程上下文,各线程争夺cpu处理,cpu在个线程直接切换,影响性能。线程池的推出,就是为了方便的控制线程数量。

线程池原理——概念

1、线程池管理器:用于创建并管理线程池,包括创建线程池,销毁线程池,添加新任务。
2、工作线程:线程池中线程,在没有任务时处于等待状态,可以循环的执行任务;
3、任务接口:每个任务必须实现的接口,以供工作线程的执行,它主要规定了任务的入口,任务执行完成的收尾工作,任务的执行状态等;
4、任务队列:用于存放没有处理的任务。提供一种缓冲机制。
在这里插入图片描述

线程池API——接口定义和实现类

类型名称描述
接口Executor最顶层的接口,定义了执行任务的方法execute
接口ExecutorService继承了Executor接口,扩展了Callable、Future、关闭方法
接口ScheduledExecutorService继承了ExecutorService,增加了定时任务相关的方法
实现类ThreadPoolExecutor基础、标准的线程池实现
实现类ScheduledThreadPoolExecutor继承了ThreadPoolExcutor,实现了ScheduledExecutorService中相关定时任务的方法

在这里插入图片描述
在这里插入图片描述

ExecutorService接口文档

各类关系图,实线表示继承,虚线表示接口实线。蓝色实现为类继承,绿色实线表示接口继承。
在这里插入图片描述

任务执行过程

在这里插入图片描述

线程数量

如何确定合适数量的线程?
计算型任务:CPU数量的1-2倍
IO型任务:相对比计算型任务,需要更多一些线程,要根据距离的IO阻塞时长进行考量决定。如tomcat中默认的最大线程数为:200。
也可考虑根据需要在一个最小数量和最大数量间自动增减线程数。
CPU使用率低于80%比较好。太小了,CPU又没合理利用起来。

测试代码

每个都取执行一下就懂了

package com.ly.study.base;

import java.util.List;
import java.util.concurrent.*;


/**
 * 线程池的使用
 */
public class ExecutorsTest {

    /**
     * 测试: 提交15个执行时间需要3秒的任务,看线程池的状况
     *
     * @param threadPoolExecutor 传入不同的线程池,看不同的结果
     * @throws Exception
     */
    public void testCommon(ThreadPoolExecutor threadPoolExecutor) throws Exception {
        // 测试: 提交15个执行时间需要3秒的任务,看超过大小的2个,对应的处理情况
        for (int i = 0; i < 15; i++) {
            int n = i;
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("开始执行:" + n);
                        Thread.sleep(3000L);
                        System.err.println("执行结束:" + n);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            System.out.println("任务提交成功 :" + i);
        }
        // 查看线程数量,查看队列等待数量
        Thread.sleep(500L);
        System.out.println("当前线程池线程数量为:" + threadPoolExecutor.getPoolSize());
        System.out.println("当前线程池等待的数量为:" + threadPoolExecutor.getQueue().size());
        // 等待15秒,查看线程数量和队列数量(理论上,会被超出核心线程数量的线程自动销毁)
        Thread.sleep(15000L);
        System.out.println("当前线程池线程数量为:" + threadPoolExecutor.getPoolSize());
        System.out.println("当前线程池等待的数量为:" + threadPoolExecutor.getQueue().size());
    }

    /**
     * 1、线程池信息: 核心线程数量5,最大数量10,无界队列,超出核心线程数量的线程存活时间:5秒, 指定拒绝策略的
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest1() throws Exception {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>());
        testCommon(threadPoolExecutor);
        // 预计结果:线程池线程数量为:5,超出数量的任务,其他的进入队列中等待被执行
    }

    /**
     * 2、 线程池信息: 核心线程数量5,最大数量10,队列大小3,超出核心线程数量的线程存活时间:5秒, 指定拒绝策略的
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest2() throws Exception {
        // 创建一个 核心线程数量为5,最大数量为10,等待队列最大是3 的线程池,也就是最大容纳13个任务。
        // 默认的策略是抛出RejectedExecutionException异常,java.util.concurrent.ThreadPoolExecutor.AbortPolicy
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.err.println("有任务被拒绝执行了");
            }
        });
        testCommon(threadPoolExecutor);
        // 预计结果:
        // 1、 5个任务直接分配线程开始执行
        // 2、 3个任务进入等待队列
        // 3、 队列不够用,临时加开5个线程来执行任务(5秒没活干就销毁)
        // 4、 队列和线程池都满了,剩下2个任务,没资源了,被拒绝执行。
        // 5、 任务执行,5秒后,如果无任务可执行,销毁临时创建的5个线程
    }

    /**
     * 3、 线程池信息: 核心线程数量5,最大数量5,无界队列,超出核心线程数量的线程存活时间:5秒
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest3() throws Exception {
        // 和Executors.newFixedThreadPool(int nThreads)一样的
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>());
        testCommon(threadPoolExecutor);
        // 预计结:线程池线程数量为:5,超出数量的任务,其他的进入队列中等待被执行
    }

    /**
     * 4、 线程池信息:
     * 核心线程数量0,最大数量Integer.MAX_VALUE,SynchronousQueue队列,超出核心线程数量的线程存活时间:60秒
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest4() throws Exception {

        // SynchronousQueue,实际上它不是一个真正的队列,因为它不会为队列中元素维护存储空间。与其他队列不同的是,它维护一组线程,这些线程在等待着把元素加入或移出队列。
        // 在使用SynchronousQueue作为工作队列的前提下,客户端代码向线程池提交任务时,
        // 而线程池中又没有空闲的线程能够从SynchronousQueue队列实例中取一个任务,
        // 那么相应的offer方法调用就会失败(即任务没有被存入工作队列)。
        // 此时,ThreadPoolExecutor会新建一个新的工作者线程用于对这个入队列失败的任务进行处理(假设此时线程池的大小还未达到其最大线程池大小maximumPoolSize)。

        // 和Executors.newCachedThreadPool()一样的
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>());
        testCommon(threadPoolExecutor);
        // 预计结果:
        // 1、 线程池线程数量为:15,超出数量的任务,其他的进入队列中等待被执行
        // 2、 所有任务执行结束,60秒后,如果无任务可执行,所有线程全部被销毁,池的大小恢复为0
        Thread.sleep(60000L);
        System.out.println("60秒后,再看线程池中的数量:" + threadPoolExecutor.getPoolSize());
    }

    /**
     * 5、 定时执行线程池信息:3秒后执行,一次性任务,到点就执行 <br/>
     * 核心线程数量5,最大数量Integer.MAX_VALUE,DelayedWorkQueue延时队列,超出核心线程数量的线程存活时间:0秒
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest5() throws Exception {
        // 和Executors.newScheduledThreadPool()一样的
        ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
        threadPoolExecutor.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("任务被执行,现在时间:" + System.currentTimeMillis());
            }
        }, 3000, TimeUnit.MILLISECONDS);
        System.out.println(
                "定时任务,提交成功,时间是:" + System.currentTimeMillis() + ", 当前线程池中线程数量:" + threadPoolExecutor.getPoolSize());
        // 预计结果:任务在3秒后被执行一次
    }

    /**
     * 6、 定时执行线程池信息:线程固定数量5 ,<br/>
     * 核心线程数量5,最大数量Integer.MAX_VALUE,DelayedWorkQueue延时队列,超出核心线程数量的线程存活时间:0秒
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest6() throws Exception {
        ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
        // 周期性执行某一个任务,线程池提供了两种调度方式,这里单独演示一下。测试场景一样。
        // 测试场景:提交的任务需要3秒才能执行完毕。看两种不同调度方式的区别
        // 效果1: 提交后,2秒后开始第一次执行,之后每间隔1秒,固定执行一次(如果发现上次执行还未完毕,则等待完毕,完毕后立刻执行)。
        // 也就是说这个代码中是,3秒钟执行一次(计算方式:每次执行三秒,间隔时间1秒,执行结束后马上开始下一次执行,无需等待)
        threadPoolExecutor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务-1 被执行,现在时间:" + System.currentTimeMillis());
            }
        }, 2000, 1000, TimeUnit.MILLISECONDS);

        // 效果2:提交后,2秒后开始第一次执行,之后每间隔1秒,固定执行一次(如果发现上次执行还未完毕,则等待完毕,等上一次执行完毕后再开始计时,等待1秒)。
        // 也就是说这个代码钟的效果看到的是:4秒执行一次。 (计算方式:每次执行3秒,间隔时间1秒,执行完以后再等待1秒,所以是 3+1)
        threadPoolExecutor.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务-2 被执行,现在时间:" + System.currentTimeMillis());
            }
        }, 2000, 1000, TimeUnit.MILLISECONDS);
    }

    /**
     * 7、 终止线程:线程池信息: 核心线程数量5,最大数量10,队列大小3,超出核心线程数量的线程存活时间:5秒, 指定拒绝策略的
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest7() throws Exception {
        // 创建一个 核心线程数量为5,最大数量为10,等待队列最大是3 的线程池,也就是最大容纳13个任务。
        // 默认的策略是抛出RejectedExecutionException异常,java.util.concurrent.ThreadPoolExecutor.AbortPolicy
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.err.println("有任务被拒绝执行了");
            }
        });
        // 测试: 提交15个执行时间需要3秒的任务,看超过大小的2个,对应的处理情况
        for (int i = 0; i < 15; i++) {
            int n = i;
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("开始执行:" + n);
                        Thread.sleep(3000L);
                        System.err.println("执行结束:" + n);
                    } catch (InterruptedException e) {
                        System.out.println("异常:" + e.getMessage());
                    }
                }
            });
            System.out.println("任务提交成功 :" + i);
        }
        // 1秒后终止线程池
        Thread.sleep(1000L);
        threadPoolExecutor.shutdown();
        // 再次提交提示失败
        threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("追加一个任务");
            }
        });
        // 结果分析
        // 1、 10个任务被执行,3个任务进入队列等待,2个任务被拒绝执行
        // 2、调用shutdown后,不接收新的任务,等待13任务执行结束
        // 3、 追加的任务在线程池关闭后,无法再提交,会被拒绝执行
    }

    /**
     * 8、 立刻终止线程:线程池信息: 核心线程数量5,最大数量10,队列大小3,超出核心线程数量的线程存活时间:5秒, 指定拒绝策略的
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest8() throws Exception {
        // 创建一个 核心线程数量为5,最大数量为10,等待队列最大是3 的线程池,也就是最大容纳13个任务。
        // 默认的策略是抛出RejectedExecutionException异常,java.util.concurrent.ThreadPoolExecutor.AbortPolicy
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.err.println("有任务被拒绝执行了");
            }
        });
        // 测试: 提交15个执行时间需要3秒的任务,看超过大小的2个,对应的处理情况
        for (int i = 0; i < 15; i++) {
            int n = i;
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("开始执行:" + n);
                        Thread.sleep(3000L);
                        System.err.println("执行结束:" + n);
                    } catch (InterruptedException e) {
                        System.out.println("异常:" + e.getMessage());
                    }
                }
            });
            System.out.println("任务提交成功 :" + i);
        }
        // 1秒后终止线程池
        Thread.sleep(1000L);
        List<Runnable> shutdownNow = threadPoolExecutor.shutdownNow();
        // 再次提交提示失败
        threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("追加一个任务");
            }
        });
        System.out.println("未结束的任务有:" + shutdownNow.size());

        // 结果分析
        // 1、 10个任务被执行,3个任务进入队列等待,2个任务被拒绝执行
        // 2、调用shutdownnow后,队列中的3个线程不再执行,10个线程被终止
        // 3、 追加的任务在线程池关闭后,无法再提交,会被拒绝执行
    }

    public static void main(String[] args) throws Exception {
//		new ExecutorsTest().threadPoolExecutorTest1();
//		new ExecutorsTest().threadPoolExecutorTest2();
//		new ExecutorsTest().threadPoolExecutorTest3();
//		new ExecutorsTest().threadPoolExecutorTest4();
		new ExecutorsTest().threadPoolExecutorTest5();
//		new ExecutorsTest().threadPoolExecutorTest6();
//		new ExecutorsTest().threadPoolExecutorTest7();
//        new ExecutorsTest().threadPoolExecutorTest8();
    }
}
Java并发编程中,线程池是一个非常重要的概念。它通过复用预先创建好的一组工作线程来执行提交的任务,以此减少频繁创建销毁线程所带来的开销,并且可以有效地控制最大并发数,提高应用程序的整体性能。 ### Java 线程池的基本组成元素 1. **核心线程数 (corePoolSize)** - 当新任务到来时,首先会尝试分配给空闲的核心线程处理;如果所有核心线程都在忙,则进入下一步骤。 2. **最大线程数 (maximumPoolSize)** - 表示允许的最大活动线程数目。一旦达到此上限值,后续到达的任务将暂时放入阻塞队列等待资源释放后再被执行。 3. **保持时间 (keepAliveTime)** - 对于超出核心线程以外的工作线程来说,在没有新任务的情况下持续存在的最长时间之后就会被回收掉以节省系统资源。 4. **任务队列 (workQueue)** - 用于保存待处理任务的数据结构,通常是指定长度的BlockingQueue实现类。例如: * `LinkedBlockingQueue`: 可选容量大小,默认无界队列; * `SynchronousQueue`: 特殊情况下的直接传递型队列,每次put操作都需要有一个take操作与之配对发生才能成功完成入队动作; * 其他定制化的缓存策略也可以根据需求自行设计实现。 5. **拒绝策略 (RejectedExecutionHandler)** - 当线程池关闭或者是当前负载过高以至于不能再接受新的请求时所采取的动作。四种内置的方式分别是抛出异常、丢弃旧任务、抛弃最新加入者或是让调用方自己跑起来该次作业等。 6. **线程工厂(ThreadFactory)** – 负责制造新的Thread实体对象的过程封装体,默认行为只是简单地new Thread()而已但用户完全可以按照自身偏好替换成更为复杂的构造形式以便更好地管理和跟踪各个子单元的状态变化趋势。 7. **Callable 和 Future** - Callable 接口类似于 Runnable ,但它可以返回结果并能抛出受检异常(FutureTask),Future 提供了一种获取异步计算结果的方法。 ### 工作流程简介 当向ThreadPoolExecutor提交一个任务时,大致经历以下几个步骤: - 如果正在运行的线程少于 corePoolSize ,即使其他工人也有闲置,仍会优先启动新的工作者来承担此项差事直到数量达标为止; - 若已经有足够的基本成员在线且仍有未决事项,则将其追加到指定容器内排队等候调度安排; - 再次检查是否超过 maximumPoolSize 的极限约束条件,若是则激活 RejectedExecutionHandler 进行相应处置措施避免死锁现象的发生; - 最终由可用的线程取出队首位置处的任务开始正式运作直至结束整个生命周期。 ### 总结 合理利用好Java中的线程池机制可以帮助开发者写出高效稳定的服务端程序。然而实际编码过程中还需要结合具体情况综合权衡各方面的因素选取合适的参数设置组合方案,这样才能真正发挥其优势特性最大化提升整体效能水平。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值