JAVA多线程04——线程池篇

最新推荐文章于 2024-08-20 14:34:44 发布
最新推荐文章于 2024-08-20 14:34:44 发布
阅读量133 收藏
点赞数
分类专栏： Java多线程 文章标签： java 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37834397/article/details/114329653
版权

1. 线程池概述

  • 概念：线程池其实就是一个容纳了多个线程的容器，其中的线程可以复用
  • 优势：
1.降低资源消耗，减少线程反复创建和销毁的资源浪费
2.提高响应速度，当线程池中有空闲线程时，任务能立即执行
3.控制线程数量，每一个线程都占用内存空间，线程池可以通过控制和管理线程数，避免内存消耗过大

2. 线程池使用

2.1 创建线程池

通常使用ThreadPoolExecutor类手动创建线程池

    private void createThreadPoolExecutor(){
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2, //核心线程数
                5, //最大线程数
                2, //新开线程的存活时间
                TimeUnit.SECONDS, //存活时间的单位
                new LinkedBlockingQueue<>(2), //等待队列 可指定容量，未指定时为无界队列
                Executors.defaultThreadFactory(), //线程工厂 默认就是Executors.defaultThreadFactory()
                (r, executor) -> System.err.println("有任务被拒绝执行了") //拒绝策略 默认抛出RejectedExecutionException异常
        );
    }

注1：ThreadPoolExecutor类的构造方法有四种，上述构造方法为了解释全部参数，用了最全的一种，其他三种构造方法分别是在上述入参中不传线程工厂或拒绝策略或都不传，详细信息可去该类中查看。
注2：Executors类中有很多静态方法可以快速创建线程池，可看情况使用

2.2 线程池使用与分析
  • 情景一分析：当线程池的等待队列为无界队列时，超出核心线程数的线程都进入了等待队列
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description 线程池的使用
 * @Author lin
 * @Date 2021/3/3 19:50
 */
public class ThreadPoolExecutorDemo {
    public static void main(String[] args) throws InterruptedException {
        //线程池信息：核心线程为2，最大线程为3，新开线程存活3秒，无界队列
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 3, 3, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        for (int i = 1; i <= 4; i++) {
            int n = i;
            threadPoolExecutor.submit(() -> { //用submit提交任务
                try {
                    System.out.println("开始执行:" + n);
                    Thread.sleep(2000L);
                    System.out.println("执行结束:" + n);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            System.out.println("任务提交成功 :" + i);
        }
        // 查看线程数量，查看队列等待数量
        Thread.sleep(1000L);
        System.out.println("当前线程池线程数量为:" + threadPoolExecutor.getPoolSize());
        System.out.println("当前线程池等待的数量为:" + threadPoolExecutor.getQueue().size());
        // 等所有任务结束时，查看线程数量，查看队列等待数量
        Thread.sleep(5000L);
        System.out.println("当前线程池线程数量为:" + threadPoolExecutor.getPoolSize());
        System.out.println("当前线程池等待的数量为:" + threadPoolExecutor.getQueue().size());
    }
}
//执行结果：
//任务提交成功 :1
//任务提交成功 :2
//开始执行:1
//任务提交成功 :3
//任务提交成功 :4
//开始执行:2
//当前线程池线程数量为:2
//当前线程池等待的数量为:2
//执行结束:1
//开始执行:3
//执行结束:2
//开始执行:4
//执行结束:3
//执行结束:4
//当前线程池线程数量为:2
//当前线程池等待的数量为:0
  • 情景二分析：将线程池的最大线程数设为2，等待队列容量设为1，可以发现当任务数超过了核心线程数与等待队列容量之和，但线程数少于最大线程数时，新开了一个线程，在任务全部执行结束后，该线程在存活时间后被销毁
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description 线程池的使用
 * @Author lin
 * @Date 2021/3/3 19:50
 */
public class ThreadPoolExecutorDemo {
    public static void main(String[] args) throws InterruptedException {
        //线程池信息：核心线程为2，最大线程为3，新开线程存活3秒，队列容量为1
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 3, 3, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(1));
        for (int i = 1; i <= 4; i++) {
            int n = i;
            threadPoolExecutor.submit(() -> { //用submit提交任务
                try {
                    System.out.println("开始执行:" + n);
                    Thread.sleep(2000L);
                    System.out.println("执行结束:" + n);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            System.out.println("任务提交成功 :" + i);
        }
        // 查看线程数量，查看队列等待数量
        Thread.sleep(1000L);
        System.out.println("当前线程池线程数量为:" + threadPoolExecutor.getPoolSize());
        System.out.println("当前线程池等待的数量为:" + threadPoolExecutor.getQueue().size());
        // 等所有任务结束时，查看线程数量，查看队列等待数量
        Thread.sleep(5000L);
        System.out.println("当前线程池线程数量为:" + threadPoolExecutor.getPoolSize());
        System.out.println("当前线程池等待的数量为:" + threadPoolExecutor.getQueue().size());
    }
}
//执行结果：
//任务提交成功 :1
//任务提交成功 :2
//开始执行:1
//任务提交成功 :3
//开始执行:2
//任务提交成功 :4
//开始执行:4
//当前线程池线程数量为:3
//当前线程池等待的数量为:1
//执行结束:1
//执行结束:2
//执行结束:4
//开始执行:3
//执行结束:3
//当前线程池线程数量为:2
//当前线程池等待的数量为:0
  • 情景三分析：将线程池的最大线程数设为2，等待队列容量设为1，可以发现当任务数超过了核心线程数与等待队列容量之和，但线程数等于最大线程数时，新的任务被拒绝
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description 线程池的使用
 * @Author lin
 * @Date 2021/3/3 19:50
 */
public class ThreadPoolExecutorDemo {
    public static void main(String[] args) throws InterruptedException {
        //线程池信息：核心线程为2，最大线程为2，新开线程存活3秒，队列容量为1
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 2, 3, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(1), (r, executor) -> System.err.println("有任务被拒绝执行了"));
        for (int i = 1; i <= 4; i++) {
            int n = i;
            threadPoolExecutor.submit(() -> { //用submit提交任务
                try {
                    System.out.println("开始执行:" + n);
                    Thread.sleep(2000L);
                    System.out.println("执行结束:" + n);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            System.out.println("任务提交成功 :" + i);
        }
        // 查看线程数量，查看队列等待数量
        Thread.sleep(1000L);
        System.out.println("当前线程池线程数量为:" + threadPoolExecutor.getPoolSize());
        System.out.println("当前线程池等待的数量为:" + threadPoolExecutor.getQueue().size());
        // 等所有任务结束时，查看线程数量，查看队列等待数量
        Thread.sleep(5000L);
        System.out.println("当前线程池线程数量为:" + threadPoolExecutor.getPoolSize());
        System.out.println("当前线程池等待的数量为:" + threadPoolExecutor.getQueue().size());
    }
}
//执行结果：
//任务提交成功 :1
//任务提交成功 :2
//开始执行:1
//任务提交成功 :3
//有任务被拒绝执行了
//任务提交成功 :4
//开始执行:2
//当前线程池线程数量为:2
//当前线程池等待的数量为:1
//执行结束:1
//执行结束:2
//开始执行:3
//执行结束:3
//当前线程池线程数量为:2
//当前线程池等待的数量为:0
2.3 一些特殊线程池
  • 缓存线程池：核心线程数为0，最大线程数为线程最大值，无界队列。这种线程池适用于任务数量不确定的情况，最好使用方式一指定最大线程数
    private void newCachedThreadPool() {
    	//以下两种方式创建方式效果一样
        new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<>()); //方式1
        Executors.newCachedThreadPool(); //方式2
    }
  • 定时执行线程池
import java.util.concurrent.*;

/**
 * @Description 定时执行线程池
 * @Author lin
 * @Date 2021/3/3 19:50
 */
public class ThreadPoolExecutorDemo {
    public static void main(String[] args) {
        new ThreadPoolExecutorDemo().threadPoolExecutorTest1();
        new ThreadPoolExecutorDemo().threadPoolExecutorTest2();
    }

    /**
     * 任务提交3秒后执行
     */
    private void threadPoolExecutorTest1() {
        //和Executors.newScheduledThreadPool()一样
        ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
        threadPoolExecutor.schedule(() -> System.out.println("一次性任务执行时间：" + System.currentTimeMillis()), 3000L, TimeUnit.MILLISECONDS);
        System.out.println("一次性任务提交时间：" + System.currentTimeMillis());
    }

    /**
     * 定时任务
     */
    private void threadPoolExecutorTest2() {
        long currentTimeMillis = System.currentTimeMillis();
        ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
        //当运行周期大于周期间隔时，下一个任务会立即执行
        threadPoolExecutor.scheduleAtFixedRate(() -> {
            try {
                Thread.sleep(3000L);//运行时间3s
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("定时任务1执行时间：" + (System.currentTimeMillis() - currentTimeMillis));
        }, 2000L, 1000L, TimeUnit.MILLISECONDS); //周期间隔1s
        //无论周期时长如何，下一个任务都会执行延时
        threadPoolExecutor.scheduleWithFixedDelay(() -> {
            try {
                Thread.sleep(3000L);//运行时间3s
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("定时任务2执行时间：" + (System.currentTimeMillis() - currentTimeMillis));
        }, 2000L, 1000L, TimeUnit.MILLISECONDS); //延时1s
    }
}
//执行结果：任务1的时间间隔约为3s,任务2的时间间隔约为4s
//一次性任务提交时间：1614776434219
//一次性任务执行时间：1614776437219
//定时任务2执行时间：5004
//定时任务1执行时间：5004
//定时任务1执行时间：8004
//定时任务2执行时间：9005
//定时任务1执行时间：11005
//定时任务2执行时间：13006
2.4 关闭线程池
import java.util.concurrent.*;

/**
 * @Description 关闭线程池
 * @Author lin
 * @Date 2021/3/3 19:50
 */
public class ThreadPoolExecutorDemo {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 5, 3, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3), (r, executor) -> System.err.println("有任务被拒绝执行了"));
        for (int i = 1; i <= 2; i++) {
            int n = i;
            threadPoolExecutor.submit(() -> {
                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.shutdownNow(); //关闭后已提交任务被打断 sleep interrupted
        // 线程池关闭后，再提交线程将被拒绝
        threadPoolExecutor.submit(() -> System.out.println("追加一个任务"));
    }
}
//shutdown执行结果：
//任务提交成功 :1
//开始执行：1
//任务提交成功 :2
//开始执行：2
//有任务被拒绝执行了
//执行结束:2
//执行结束:1

//shutdownNow执行结果：
//任务提交成功 :1
//任务提交成功 :2
//开始执行：1
//开始执行：2
//sleep interrupted
//sleep interrupted
//有任务被拒绝执行了
林公子202102
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
【JavaEE初阶系列】——多线程案例三——定时器
2301_76278775的博客
04-08 814
MyTask类用于描述一个任务作为Timer的内部类).里面包含一个Runnable对象和一个time(毫秒时间戳)
java多线程案例——未完成
08-21
Java多线程是Java编程中的一个重要领域，它允许程序同时执行多个任务，从而提高系统效率和资源利用率。在这个未完成的案例中，我们可能正在探讨如何在Java中创建和管理线程，以及处理多线程环境下的并发问题。下面是...
Java多线程——System.currentTimeMillis()与System.nanoTime()的区别
laoXingyao的博客
05-24 2016
1. System.currentTimeMillis()返回当前时间，是从1970.1.1 UTC 零点开始到当前时刻的时间差，单位为毫秒(ms)，可根据currentTimeMillis()返回的时间戳来计算当前日期，进而和Date进行转换。2. System.nanoTime()返回随机时间种子，单位为毫微妙（即纳秒ns)，时间精度比currentTimeMillis()高，但是不能用来计算...
线程 3
m0_70386582的博客
01-07 660
线程3
java中的1L是啥意思？
热门推荐
weixin_34336292的博客
07-24 1万+
2019独角兽企业重金招聘Python工程师标准>>> ...
java currenttimemillis 效率_高并发场景下System.currentTimeMillis()的性能问题的优化
weixin_42107374的博客
02-27 173
1 packagecn.ucaner.alpaca.common.util.key;23 importjava.sql.Timestamp;4 import java.util.concurrent.*;5 importjava.util.concurrent.atomic.AtomicLong;67 /**8 * 高并发场景下System.currentTimeMillis()的性能问题的优化9...
Java多线程案例——线程池
如风暖阳的博客
05-11 9755
Java多线程案例——线程池
Java多线程案例——线程池及ThreadPoolExecutor类
小小码农
01-11 2058
Java多线程案例——线程池及ThreadPoolExecutor类
Java多线程——线程池
u010759175的专栏
12-28 264
public class TestPool { public static void main(String[] args){ ExecutorService executorService = Executors.newFixedThreadPool(3); MyThread myThread = new MyThread(); executorService.execute(myThread); executorService.execute(myThread); executor
Java进阶学习——Java多线程知识的理解
01-20
Java多线程知识的理解0.前言1.从一道题目引入2.创建线程2.1.继承Thread类2.2.实现Runnable接口3.线程的生命周期4.线程安全4.1.为什么需要线程安全？4.2.如何实现线程安全？5.线程池5.1.为什么需要线程池？5.2.创建...
轻量级java多线程池demo
01-08
本文将深入探讨一个轻量级的Java多线程池实现，这个实现允许线程间的通信，并提供了类似Akka Actor的调度功能。 首先，我们要理解Java中的线程池。线程池是一种线程使用模式，它维护一组可以重复使用的线程，避免了...
smoker_java多线程_
09-29
标题"smoker_java多线程_"暗示我们将探讨的是一个关于Java多线程的示例，可能是解决某个特定的并发问题。描述中提到的"实现经典多线程问题中的多线程问题"进一步说明我们将深入研究一些常见的多线程挑战，例如死锁、...
Java多线程之定时任务 以及 SpringBoot多线程实现定时任务——异步任务
03-12
1. SpringBoot 自定义线程池以及多线程间的异步调用（@Async、@EnableAsync） 2.Java多线程之定时任务 以及 SpringBoot多线程实现定时任务 3.@EnableScheduling 与 @Scheduled
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 933
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
【Spring框架】
m0_71941456的博客
08-18 974
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 482
【代码】springboot网上商品订单转手系统bootpf
总结常见报错信息
m0_68903702的博客
08-16 353
在@Controller注解中，返回的是字符串或者是字符串匹配的模板名称，即直接渲染视图，与html页面配合使用的，java后端的代码要结合html的情况进行渲染,使用model对象（或者modelandview）的数据将填充user视图中的相关属性，然后展示到浏览器；而在@RestController中，返回的应该是一个对象，即return一个user对象，这时，在没有页面的情况下，也能看到返回的是一个user对象对应的json字符串。情形一：若前端传入Json格式，后端使用。
android apk 加固后的地图加载异常及重新签名
最新发布
calivnBao的博客
08-20 138
android apk 加固后的地图加载异常及重新签名
基于vue框架的爱看电影网站v4o92（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
08-15 1024
项目功能：用户,电影分类,电影信息,电影评分基于Vue框架的爱看电影网站项目功能丰富多样，旨在为用户提供一个集电影浏览、信息查询、观影体验、互动交流于一体的综合性平台。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值