Java Springboot 线程池使用

已于 2022-01-24 01:29:18 修改
阅读量1.4k 收藏
点赞数
分类专栏： JavaWeb 服务框架 文章标签： Java 线程 Thread springboot
于 2021-04-29 00:23:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42176639/article/details/116137754
版权

Java Springboot 线程池使用

一、基本概念

1.进程：一个程序的执行，包含多个线程
2.线程：一个程序执行中的片段但，进程执行中的最小单位
3.使用场景：
        ①后台任务：定时发送大量邮件
        ②异步处理：统计、日志
        ③分布式计算、分片下载、断点续传
4.用户线程和守护线程
用户线程：程序本身执行的线程
守护线程：为程序提供通用服务的线程（GC 垃圾回收线程）
用户线程存在，JVM不会离开；用户线程执行完成退出，无论守护线程是否存在，JVM都将离开
5.同一CPU内核，同一时间，只能执行一个线程
   线程调度器，分配时间片
   线程优先级分为10级，1最低，10最高
6.线程的停止：采用中断
7.线程的状态：
        ①NEW
        ②RUNNABLE
        ③BLOCKED
        ④WAITING
        ⑤TIMED_WAITING
        ⑥TERMINATED
在这里插入图片描述
8.控制线程执行顺序：join方法（优先级是提高概率，并不绝对）
9.线程安全：子线程访问共享变量，共享变量在主内存中，访问时会将共享变量拷贝至自己的工作内存，操作完成后再写回主变量
10.Java并发编程三大特性：原子性、可见性、有序性

二、线程演示
1.线程创建

package com.atguigu.thread;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * Description: 多线程Demo
 *
 * @Author: 
 * @Date: 2021-04-25 20:53
 * @version: V1.0.0
 */
@Slf4j
public class ThreadDemo {

    private static int num=10;

    public static void main(String[] args) {

        /**
         * 采用继承的方式，只能单继承Thread
         * 采用实现接口的方式，可以在实现接口的基础上再进行一次继承
         * 同时，采用接口的写法可以改为匿名内部类的方式，进一步简化为Lambda表达式形式
         */

        TestThread testThread = new TestThread();
        testThread.start();

        Thread thread = new Thread(new TestRunnable());
        thread.start();

        Thread threadN = new Thread(new Runnable(){
            @Override
            public void run(){
                log.info("匿名内部类形式");
            }
        });
        threadN.start();

        Thread threadL = new Thread(()->{
            log.info("Lambda表达式形式");
        });
        threadL.start();

        /**
         * 带返回值的线程
         */
        FutureTask<Integer> futureTask = new FutureTask<>(new TestCallable());
        Thread threadRet = new Thread(futureTask);
        threadRet.start();
        try {
            //得到线程执行处理结果
            Integer result = futureTask.get();
            log.info("得到线程执行处理结果:{}",result);
        }catch (ExecutionException exception) {
            log.error("",exception);
        }catch (InterruptedException exception) {
            log.error("",exception);
        }

    }

    /**
     * 继承Thead类，实现Run方法
     */
    static class TestThread extends Thread{
        @Override
        public void run(){
            for (int i=0;i<num;i++){
                log.info("Print 【{}】 Times",i);
            }
        }
    }

    /**
     * 实现Runnable接口，实现Run方法
     */
    static class TestRunnable implements Runnable{

        @Override
        public void run() {
            for (int i=0;i<num;i++){
                log.info("Print 【{}】 Times",i);
            }
        }
    }

    /**
     * 实现Callable接口，实现带返回值的任务
     */
    static class TestCallable implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {
            int sum=0;
            for (int i=0;i<num;i++){
                log.info("Print 【{}】 Times",i);
                sum+=i;
            }
            return sum;
        }
    }

}

2.线程停止

package com.atguigu.thread;

import lombok.extern.slf4j.Slf4j;

/**
 * Description: 线程停止的方法
 *
 * @Author: 
 * @Date: 2021-04-25 21:47
 * @version: V1.0.0
 */
@Slf4j
public class ThreadStopDemo {


    /**
     * 优雅的终止线程
     * threadTest.interrupt() 中断线程
     * Thread.currentThread().isInterrupted() 线程是否中断
     * @param args
     */
    public static void main(String[] args) {

        Thread threadTest = new Thread(()->{
            while (true){
                if(Thread.currentThread().isInterrupted()){
                    break;
                }
                log.info("线程执行中......");
            }
        });
        threadTest.start();
        /**
         * 主线程休眠2秒
         * 然后将子线程中断
         */
        try {
            Thread.sleep(2000);
            threadTest.interrupt();
        } catch (InterruptedException interruptedException) {
            interruptedException.printStackTrace();
        }
    }
}

3.用户线程和守护线程

package com.atguigu.thread;

import lombok.extern.slf4j.Slf4j;

/**
 * Description: 用户线程和守护线程测试
 *
 * @Author: 
 * @Date: 2021-04-25 21:27
 * @version: V1.0.0
 */
@Slf4j
public class ThreadDaemonDemo {

    private static int num = 100;

    /**
     * new Thread 默认为非守护进程
     * 设置为守护进程后，当threadUser执行完成时，threadDaemon立即结束
     * @param args
     */
    public static void main(String[] args) {

        /**
         * 守护线程
         */

        Thread threadDaemon = new Thread(()->{
            for (int i=0;i<num;i++){
                try {
                    Thread.sleep(200);
                    log.info("守护线程：【{}】",i);
                } catch (InterruptedException interruptedException) {
                    interruptedException.printStackTrace();
                }
            }
        });
        threadDaemon.setDaemon(false);
        threadDaemon.start();

        /**
         * 用户线程
         */

        Thread threadUser = new Thread(()->{
            for (int i=0;i<num;i++){
                try {
                    Thread.sleep(50);
                    log.info("用户线程：【{}】",i);
                } catch (InterruptedException interruptedException) {
                    interruptedException.printStackTrace();
                }
            }
        });
        threadUser.start();
    }
}

4.线程优先级

package com.atguigu.thread;

import lombok.extern.slf4j.Slf4j;

/**
 * Description: 线程优先级测试
 *
 * @Author: 
 * @Date: 2021-04-25 21:36
 * @version: V1.0.0
 */
@Slf4j
public class ThreadPriority {

    private static int num = 100;

    /**
     * 设置优先级1-10 默认为5
     * @param args
     */
    public static void main(String[] args) {

        /**
         * 守护线程
         */

        Thread threadFirst = new Thread(()->{
            for (int i=0;i<num;i++){
                log.info("线程1：【{}】",i);
            }
        });
        threadFirst.setPriority(1);
        threadFirst.start();

        /**
         * 用户线程
         */

        Thread threadSecond = new Thread(()->{
            for (int i=0;i<num;i++){
                log.info("线程2：【{}】",i);
            }
        });
        threadSecond.setPriority(10);
        threadSecond.start();
    }
}

5.线程顺序执行

package com.atguigu.thread;

import lombok.extern.slf4j.Slf4j;

/**
 * Description: 线程执行顺序
 *
 * @Author: 
 * @Date: 2021-04-25 22:22
 * @version: V1.0.0
 */
@Slf4j
public class ThreadJoin {

    private static int num = 100;

    /***
     * 控制线程T1、T2、T3按顺序执行
     * join A { B.join() } 则A会在B执行完后执行
     * @param args
     */
    public static void main(String[] args) {

        Thread t1 = new Thread(()->{
            for (int i=0;i<num;i++){
                log.info("线程0：【{}】",i);
            }
        });

        Thread t2 = new Thread(()->{
            try {
                t1.join();
            } catch (InterruptedException interruptedException) {
                interruptedException.printStackTrace();
            }
            for (int i=0;i<num;i++){
                log.info("线程1：【{}】",i);
            }
        });

        Thread t3 = new Thread(()->{
            try {
                t2.join();
            } catch (InterruptedException interruptedException) {
                interruptedException.printStackTrace();
            }
            for (int i=0;i<num;i++){
                log.info("线程2：【{}】",i);
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }
}

6.线程安全与锁（不加锁则会出现卖票混乱）

package com.atguigu.thread;

import lombok.extern.slf4j.Slf4j;

/**
 * Description: 线程安全测试
 *
 * @Author: 
 * @Date: 2021-04-25 22:53
 * @version: V1.0.0
 */
@Slf4j
public class ThreadSafeDemo {

    private static int tickets=100;

    public static void main(String[] args) {
        Object o = new Object();
        Runnable runnable = ()->{
            while (true){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException interruptedException) {
                    interruptedException.printStackTrace();
                }
                synchronized (o){
                    if(tickets>0){
                        tickets--;
                        log.info("{} 卖了一张票，剩余 {}",Thread.currentThread().getName(),tickets);
                    }else{
                        break;
                    }
                }
            }
        };

        Thread t1 = new Thread(runnable,"窗口1");
        Thread t2 = new Thread(runnable,"窗口2");
        Thread t3 = new Thread(runnable,"窗口3");
        t1.start();
        t2.start();
        t3.start();

    }
}

7.线程通信演示 等待wait和唤醒notify

package com.atguigu.thread;

import lombok.extern.slf4j.Slf4j;

/**
 * Description: 线程通信演示 等待：wait 唤醒：notify
 *
 * @Author: 
 * @Date: 2021-04-28 23:34
 * @version: V1.0.0
 */
@Slf4j
public class ThreadCommunication {

    public static void main(String[] args) {

        NumMode  numMode = new NumMode();

        /**
         * 奇数情况输出
         */
        new Thread(()->{
            while (true){
                synchronized (numMode){
                    if(numMode.num<100){
                        if(numMode.num%2!=0){
                            log.info("奇数打印：{}",numMode.num);
                            numMode.num++;
                            numMode.notify();
                        }else{
                            try {
                                numMode.wait();
                            } catch (InterruptedException interruptedException) {
                                interruptedException.printStackTrace();
                            }
                        }
                    }else {
                        break;
                    }
                }
            }
        }).start();

        /**
         * 偶数情况输出
         */
        new Thread(()->{
            while (true){
                synchronized (numMode){
                    if(numMode.num<100){
                        if(numMode.num%2==0){
                            log.info("偶数打印：{}",numMode.num);
                            numMode.num++;
                            numMode.notify();
                        }else{
                            try {
                                numMode.wait();
                            } catch (InterruptedException interruptedException) {
                                interruptedException.printStackTrace();
                            }
                        }
                    }else {
                        break;
                    }
                }
            }
        }).start();
    }

    static class NumMode{
        int num=0;
    }
}

8.消费和生产者模型演示 等待wait和唤醒notify

package com.atguigu.thread;

import lombok.extern.slf4j.Slf4j;

import java.util.LinkedList;

/**
 * Description: 生产者消费者模型
 *
 * 生产者：做手机
 * 消费者：买手机
 * 手机店：库存容量30台
 *
 * @Author: 
 * @Date: 2021-04-28 23:57
 * @version: V1.0.0
 */
@Slf4j
public class ProductionAndConsumption {

    static int version = 1;

    /**
     * 顾客
     */
    static class CustomerTask implements Runnable{
        MobileShop mobileShop;
        public CustomerTask(MobileShop mobileShop) {
            this.mobileShop = mobileShop;
        }

        @Override
        public void run() {
            while (true){
                synchronized (mobileShop){
                    if(mobileShop.phoneList.size()>0){
                        mobileShop.phoneList.poll();
                        mobileShop.notifyAll();
                        log.info(":{}购买了一台手机",Thread.currentThread().getName());
                    }else{
                        //手机抢光了
                        try {
                            mobileShop.wait();
                        } catch (InterruptedException interruptedException) {
                            interruptedException.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    /**
     * 山寨手机厂
     */
    static class ProductTask implements Runnable{

        MobileShop mobileShop;
        public ProductTask(MobileShop mobileShop) {
            this.mobileShop = mobileShop;
        }

        @Override
        public void run() {
            while (true){
                synchronized (mobileShop){
                    if(mobileShop.phoneList.size()<30){
                        Phone phone = new Phone();
                        phone.setModel("小米"+version);
                        version++;
                        mobileShop.phoneList.push(phone);
                        mobileShop.notifyAll();
                        log.info("{}:生产了一台手机，共{}版本了",Thread.currentThread().getName(),version);
                    }else{
                        //库存已满，停止生产
                        try {
                            mobileShop.wait();
                        } catch (InterruptedException interruptedException) {
                            interruptedException.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    /**
     * 手机店
     */
    static class MobileShop{
        LinkedList phoneList = new LinkedList();
    }

    /**
     * 手机
     */
    static class Phone{
        String model;
        public void setModel(String model) {
            this.model = model;
        }
        public String getModel() {
            return model;
        }

    }

    public static void main(String[] args) {
        MobileShop mobileShop = new MobileShop();
        new Thread(new ProductTask(mobileShop)).start();
        new Thread(new CustomerTask(mobileShop)).start();
        new Thread(new CustomerTask(mobileShop)).start();


    }
}
猪悟道
关注
专栏目录
springboot与其自带的线程池
chajintao
04-27 1715
springboot有一个自带的线程池类，就是ThreadPoolTaskExecutor。
java asynservice_springboot线程池@Async的使用和扩展
weixin_33256096的博客
02-23 795
我们常用ThreadPoolExecutor提供的线程池服务，springboot框架提供了@Async注解，帮助我们更方便的将业务逻辑提交到线程池中异步执行，今天我们就来实战体验这个线程池服务；实战环境windowns10；jdk1.8；springboot 1.5.9.RELEASE；开发工具：IntelliJ IDEA；实战源码本次实战的源码可以在我的GitHub下载，地址：git@gith...
springboot线程池超级详解
最新发布
xwnxwn的专栏
07-28 1050
线程，程序执行流的最小执行单位，是行程中的实际运作单位，经常容易和进程这个概念混淆。那么，线程和进程究竟有什么区别呢？首先，进程是一个动态的过程，是一个活动的实体。简单来说，一个应用程序的运行就可以被看做是一个进程，而线程，是运行中的实际的任务执行者。可以说，进程中包含了多个可以同时运行的线程。单线程，顾名思义即是只有一条线程在执行任务。多线程，创建多条线程同时执行任务，这种方式在我们的日常生活中比较常见。但是，在多线程的使用过程中，还有许多需要我们了解的概念。
快速了解Java线程池
全菜工程师小辉的博客
06-17 5932
之所以要使用线程池，是因为使用new Thread在大型项目中是有弊端的： 每次new Thread新建对象，性能差 线程缺乏统一管理，可能无限制的新建线程，相互竞争，有可能会造成过多占用系统资源而导致OOM 缺少更多功能，如定期执行等 而线程池的好处： 重用存在的线程，减少对象创建、消亡的开销，性能佳 可有效控制最大并发线程数，提高系统资源利用率，同...
spring boot中一般如何使用线程池
Programming Talk
04-26 5065
本文将详细阐述如何在Spring Boot中正确使用线程池，包括配置参数、实例化、任务提交、监控及常见问题处理等环节，并辅以代码示例，以期为开发者提供一份全面的实践指南。​，配置核心参数，正确提交任务，并借助监控工具持续观察与调整，可以显著提升应用的并发处理能力与资源利用率。线程池是一种基于池化技术管理线程的机制，其核心目标在于减少线程创建与销毁的开销，通过复用已创建的线程来处理一系列异步任务。​​是实现线程池的基础类，而Spring Boot则通过封装​。​等组件，简化了线程池的配置和使用。
java 线程池 spring_Spring线程池开发实战及使用spring注解
weixin_35327824的博客
02-15 435
本文提供了三个Spring多线程开发的例子，由浅入深，由于例子一目了然，所以并未做过多的解释。诸位一看便知。前提条件：1)在Eclipse创建一个Java项目，我取名为SpringThreadDemo。2)项目所需的JAR包如图所示： 下面开始。注：项目源码已经托管到GitHub，地址：https://github.com/chszs/SpringThreadDemo例子1：Spring结合Jav...
深入学习springboot线程池的使用和扩展
08-25
深入学习SpringBoot线程池的使用和扩展 在本篇文章中，我们将深入学习SpringBoot框架提供的线程池服务，并了解如何使用和扩展它。SpringBoot框架提供了@Async注解，帮助我们更方便的将业务逻辑提交到线程池中异步...
SpringBoot线程池详解含完整示例（值得珍藏）
01-29
Spring Boot的线程池是Java并发编程的核心工具，它提供了高效管理并发任务的能力，从而优化系统性能和响应速度。在Spring Boot中，线程池的使用涵盖了多种类型的ExecutorService实现，包括SingleThreadExecutor、...
springboot线程池配置使用
m0_67403272的博客
08-02 631
先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。网上比较多的也是通过这个注解的方式去异步，注解放在方法头上标志方法异步，放在class头上，class下的所有方法异步。这边在基本的配置上面都是大同小异，几个核心的参数也都有合适的一些值，网上都有说明，不在赘述。如果有哪里不正确的地方，欢迎指出，我会第一时间改正。...
java springboot线程池
04-08
Java Spring Boot线程池是Spring框架提供的一种用于管理和调度线程的机制。它可以帮助我们更好地管理并发任务，提高系统的性能和稳定性。 在Spring Boot中，我们可以通过配置来创建和使用线程池。以下是Java Spring...
SpringBoot 线程池
Hxuening的博客
04-19 749
代码： 线程池 参数： （1）corePoolSize：核心线程数，该参数说明了在线程池中保持核心线程的数量，由自己定义，刚创建线程池时，里面的核心线程数为0，随着任务的添加，达到核心线程数，执行完任务之后，线程池里面的核心线程数一直维持在设置的核心线程数。 （2）最大线程数（maximumPoolSize）:该参数定义了一个线程池中最多能容纳多少个线程。当一个任务提交到线程池中时，如果线程数量达到了核心线程数，并且任务队列已满，不能再向任务队列中添加任务时，这时会检查任务是否达到了最大线程数，如果未达到
SpringBoot 多任务并行+线程池处理的实现
08-27
主要介绍了SpringBoot 多任务并行+线程池处理的实现,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
线程池在springboot项目中的实际应用
xcy0_o的专栏
07-20 1081
线程池在springboot项目中的实际应用
Springboot自带线程池
weixin_45874214的博客
04-30 6202
骑着蜗牛去旅游
springboot 整合线程池
请叫我猿叔叔的博客
10-13 8789
一. 简介 二. 代码 2.1 线程池配置类 package com.yzx.caasscs.configuration.thread; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.sp...
SpringBoot中使用Spring自带线程池ThreadPoolTaskExecutor与Java8CompletableFuture实现异步任务示例
BADAO_LIUMANG_QIZHI的博客
02-05 2745
关于线程池的使用：项目开发中多使用SpringBoot，Spring中有个自带的线程池ThreadPoolTaskExecutorSpring 通过任务执行器（TaskExecutor）来实现多线程和并发编程，使用ThreadPoolTaskExecutor实现一个基于线程池的TaskExecutorThreadPoolTaskExecutor是spring core包中的，而ThreadPoolExecutor是JDK中的JUC。
springboot中的线程池
yaoct的博客
08-16 4815
1.springboot线程池定时任务类org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler 参考https://www.cnblogs.com/toiletgg/p/10647436.html ThreadPoolTaskScheduler其实底层使用也是java自带的线程池，相比于通过java自带的周期性任务线程池ScheduleThreadPoolExecutor，此bean对象支持根据cron表达式创建周期性任务。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猪悟道

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值