Spring线程池开发实战

最新推荐文章于 2024-04-22 14:21:38 发布
最新推荐文章于 2024-04-22 14:21:38 发布
阅读量335 收藏
点赞数
分类专栏： spring 文章标签： spring 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25218095/article/details/53241734
版权

Spring线程池开发实战

作者：chszs，转载需注明。

作者博客主页：http://blog.csdn.net/chszs

本文提供了三个Spring多线程开发的例子，由浅入深，由于例子一目了然，所以并未做过多的解释。诸位一看便知。

前提条件：

1）在Eclipse创建一个Java项目，我取名为SpringThreadDemo。
2）项目所需的JAR包如图所示：
 

下面开始。


注：项目源码已经托管到GitHub，地址：https://github.com/chszs/SpringThreadDemo

例子1：Spring结合Java线程。

通过继承Thread创建一个简单的Java线程，然后使用@Component让Spring容器管理此线程，Bean的范围必须是prototype，因此每个请求都会返回一个新实例，运行每个单独的线程。

PrintThread.java

package com.chszs.thread;  
  
import org.springframework.stereotype.Component;  
import org.springframework.context.annotation.Scope;  
  
@Component  
@Scope("prototype")  
public class PrintThread extends Thread{  
        @Override  
        public void run(){  
                System.out.println(getName() + " is running.");  
                try{  
                        Thread.sleep(5000);  
                }catch(InterruptedException e){  
                        e.printStackTrace();  
                }  
                System.out.println(getName() + " is running again.");  
        }  
}

AppConfig.java

[java] view plain copy print?
package com.chszs.config;  
  
import org.springframework.context.annotation.ComponentScan;  
import org.springframework.context.annotation.Configuration;  
  
@Configuration  
@ComponentScan(basePackages="com.chszs.thread")  
public class AppConfig {  
}

App.java

[java] view plain copy print?
package com.chszs;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
  
import com.chszs.config.AppConfig;  
import com.chszs.thread.PrintThread;  
  
public class App {  
        public static void main(String[] args){  
                ApplicationContext ctx =   
            new AnnotationConfigApplicationContext(AppConfig.class);  
                PrintThread printThread1 = (PrintThread)ctx.getBean("printThread");  
                printThread1.setName("Thread 1");  
                  
                PrintThread printThread2 = (PrintThread)ctx.getBean("printThread");  
                printThread2.setName("Thread 2");  
                  
                PrintThread printThread3 = (PrintThread)ctx.getBean("printThread");  
                printThread3.setName("Thread 3");  
                  
                PrintThread printThread4 = (PrintThread)ctx.getBean("printThread");  
                printThread4.setName("Thread 4");  
                  
                PrintThread printThread5 = (PrintThread)ctx.getBean("printThread");  
                printThread5.setName("Thread 5");  
                  
                printThread1.start();  
                printThread2.start();  
                printThread3.start();  
                printThread4.start();  
                printThread5.start();  
        }  
}

输出：

Thread 1 is running.
Thread 2 is running.
Thread 4 is running.
Thread 5 is running.
Thread 3 is running.
Thread 2 is running again.
Thread 1 is running again.
Thread 5 is running again.
Thread 4 is running again.
Thread 3 is running again.


例子2：Spring线程池结合非Spring托管Bean。

使用Spring的ThreadPoolTaskExecutor类创建一个线程池。执行线程无需受Spring容器的管理。

PrintTask.java

package com.chszs.thread;  
  
public class PrintTask implements Runnable{  
        String name;  
        public PrintTask(String name){  
                this.name = name;  
        }  
        @Override  
        public void run() {  
                System.out.println(name + " is running.");  
                try{  
                        Thread.sleep(5000);  
                }catch(InterruptedException e){  
                        e.printStackTrace();  
                }  
                System.out.println(name + " is running again.");  
        }  
          
}

Spring-Config.xml

<beans xmlns="http://www.springframework.org/schema/beans"  
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
        xmlns:context="http://www.springframework.org/schema/context"  
        xsi:schemaLocation="http://www.springframework.org/schema/beans  
        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
        http://www.springframework.org/schema/context  
        http://www.springframework.org/schema/context/spring-context-3.1.xsd">  
          
        <bean id="taskExecutor"   
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">  
                <property name="corePoolSize" value="5" />  
                <property name="maxPoolSize" value="10" />  
                <property name="WaitForTasksToCompleteOnShutdown" value="true" />  
        </bean>  
</beans>

注意这个Spring配置文件的位置，如图所示：



App1.java

package com.chszs;  
  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;  
  
import com.chszs.thread.PrintTask;  
  
public class App1 {  
  
        public static void main(String[] args) {  
                ApplicationContext ctx =   
            new ClassPathXmlApplicationContext("resources/Spring-Config.xml");  
                ThreadPoolTaskExecutor taskExecutor =  
            (ThreadPoolTaskExecutor)ctx.getBean("taskExecutor");  
                taskExecutor.execute(new PrintTask("Thread 1"));  
                taskExecutor.execute(new PrintTask("Thread 2"));  
                taskExecutor.execute(new PrintTask("Thread 3"));  
                taskExecutor.execute(new PrintTask("Thread 4"));  
                taskExecutor.execute(new PrintTask("Thread 5"));  
                // 检查活动的线程，如果活动线程数为0则关闭线程池  
                for(;;){  
                        int count = taskExecutor.getActiveCount();  
                        System.out.println("Active Threads : " + count);  
                        try{  
                                Thread.sleep(1000);  
                        }catch(InterruptedException e){  
                                e.printStackTrace();  
                        }  
                        if(count==0){  
                                taskExecutor.shutdown();  
                                break;  
                        }  
                }  
        }  
  
}

输出：

Thread 1 is running.
Thread 2 is running.
Thread 3 is running.
Thread 4 is running.
Active Threads : 4
Thread 5 is running.
Active Threads : 5
Active Threads : 5
Active Threads : 5
Active Threads : 5
Active Threads : 5
Thread 4 is running again.
Thread 2 is running again.
Thread 3 is running again.
Thread 1 is running again.
Thread 5 is running again.
Active Threads : 0

作者：chszs，转载需注明。博客主页：http://blog.csdn.net/chszs

例子3：Spring线程池结合Spring托管Bean。


本例仍然使用ThreadPoolTaskExecutor类，并使用@Component注释声明Spring的托管Bean。
下面的例子PrintTask2是Spring的托管Bean，使用@Autowired注释简化代码。

PrintTask2.java

package com.chszs.thread;  
  
import org.springframework.context.annotation.Scope;  
import org.springframework.stereotype.Component;  
  
@Component  
@Scope("prototype")  
public class PrintTask2 implements Runnable {  
        String name;  
  
        public void setName(String name) {  
                this.name = name;  
        }  
          
        @Override  
        public void run(){  
                System.out.println(name + " is running.");  
                try{  
                        Thread.sleep(5000);  
                }catch(InterruptedException e){  
                        e.printStackTrace();  
                }  
                System.out.println(name + " is running again.");  
        }  
}

AppConfig.java

package com.chszs.config;  
  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.ComponentScan;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;  
  
@Configuration  
@ComponentScan(basePackages="com.chszs.thread")  
public class AppConfig {  
        @Bean  
        public ThreadPoolTaskExecutor taskExecutor(){  
                ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();  
                pool.setCorePoolSize(5);  
                pool.setMaxPoolSize(10);  
                pool.setWaitForTasksToCompleteOnShutdown(true);  
                return pool;  
        }  
}

App2.java

package com.chszs;  
  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;  
  
import com.chszs.config.AppConfig;  
import com.chszs.thread.PrintTask2;  
  
public class App2 {  
        public static void main(String[] args) {  
                ApplicationContext ctx =   
            new AnnotationConfigApplicationContext(AppConfig.class);  
                ThreadPoolTaskExecutor taskExecutor =  
            (ThreadPoolTaskExecutor)ctx.getBean("taskExecutor");  
                  
                PrintTask2 printTask1 = (PrintTask2)ctx.getBean("printTask2");  
                printTask1.setName("Thread 1");  
                taskExecutor.execute(printTask1);  
                  
                PrintTask2 printTask2 = (PrintTask2)ctx.getBean("printTask2");  
                printTask2.setName("Thread 2");  
                taskExecutor.execute(printTask2);  
                  
                PrintTask2 printTask3 = (PrintTask2)ctx.getBean("printTask2");  
                printTask3.setName("Thread 3");  
                taskExecutor.execute(printTask3);  
                  
                for(;;){  
                        int count = taskExecutor.getActiveCount();  
                        System.out.println("Active Threads : " + count);  
                        try{  
                                Thread.sleep(1000);  
                        }catch(InterruptedException e){  
                                e.printStackTrace();  
                        }  
                        if(count==0){  
                                taskExecutor.shutdown();  
                                break;  
                        }  
                }  
        }  
  
}

输出：

Thread 1 is running.
Thread 2 is running.
Active Threads : 2
Thread 3 is running.
Active Threads : 3
Active Threads : 3
Active Threads : 3
Active Threads : 3
Thread 1 is running again.
Thread 2 is running again.
Thread 3 is running again.
Active Threads : 1
Active Threads : 0

从这三个简单的实例中，你是不是发现了Spring框架在多线程方面的强大之处！！








潇洒走一趟
关注
专栏目录
并发编程系列（2）- 线程池代码实战
noaman_wgs的博客
12-22 709
上一节并发编程系列（1）- 线程池原理 已经初步介绍线程池的原理、线程池的创建，但是实际在项目中应该如何使用线程池呢？ 一、使用场景介绍 当遇到重复性、且互相无依赖的任务的时候，可以用多线程来实现。 比如：上传多个文件、解析多个文件等等，这些行为相互之间不会影响（即一个任务不依赖与另一个任务的执行成功与否，也不依赖于其执行的结果）。 如果任务执行相互依赖，那么可以用异步去实现。 二、代码实战 下面...
10年IT老兵亲述SpringCloud开发从入门到实战文档
ma_xiao_qi的博客
06-13 593
java学习 成长思维导图：骆驼祥子思维导图 - GitMind首先给大家看一张图，不知道图上这些springcloud的技术知识点，大家是否都精通而灵活运用了呢？ 如果没有精通灵活运用的话，小编将用此文来带大家一步步来深入学习这些技术知识，接下来将从Spring Boot微框架搭建、Spring Cloud常用组件应用，到微服务案例实战，层层剥茧式分析，全流程讲解Spring Cloud开发应用，实战案例拿来就用，带大家快速上手。本文主要分为21章的内容给大家介绍springcloud开发从入门到实战，大
线程池实战应用
liuerchong的博客
03-31 1660
线程池的设置 corePoolSize：核心线程数 核心线程会一直存活，即使没有任务需要执行 当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理 设置allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭 （1）高并发、任务执行时间短的业务，线程池线程数可以设置为CPU核数+1，减少线程上下文的切换 （2）并发不高、任务执行时间长的业务要区分开看： a）假如是业务时间长集中在IO操作上，也就是IO密集型的任务，因为IO操作并不占用CPU，所以不要让
线程池在项目中的实战
BBQ_boys的博客
07-29 212
弄到一份宝藏级SpringCloud实战文档，Java 线程池
2401_84004078的博客
04-19 884
整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。其实面试这一块早在第一个说的25大面试专题就全都有的。以上提及的这些全部的面试+学习的各种笔记资料，我这差不多来回搞了三个多月，收集整理真的很不容易，其中还有很多自己的一些知识总结。正是因为很麻烦，所以对以上这些学习复习资料感兴趣《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
Spring注解驱动开发实战-servlet
02-16
本实战指南将深入探讨如何利用Spring的注解来实现高效、灵活的Servlet容器集成。 首先，让我们来理解`ServletContainerInitializer`。这是一个Java EE 7引入的接口，允许我们自定义初始化Servlet容器的行为。通过...
微服务开发(五) Spring Cloud 开发综合案例实践(一)
柳老师的博客
07-29 1030
项目架构的设计就像建一栋楼盘的图纸一样非常的重要,如果你是搭一间二层楼的房子,这个图纸的重要性可能不大,但是如果你是用Spring Cloud做开发,显然这将会是一栋30多层的建筑,如果图纸设计错误,造成的后果可能就是推倒重来,所以,项目前期的架构设计非常的重要,我尝试用一张图来描述这个项目的架构.
一个完整的线程池的实例
05-06
所以源代码都有 ，一个完整的线程池的实例
java 四种线程池实例
06-06
执行一个异步任务你还只是如下new Thread吗？是不是太low 了一点？ 我这里有四种线程池的案例轻松让你理解和使用线程池。
springmvc+spring线程池处理http并发请求数据同步控制问题
03-27
springmvc+spring线程池处理http并发请求数据同步控制问题
线程池、多线程项目实战
m0_65014849的博客
10-25 318
线程池、多线程项目实战
线程池实战
实践求真知
04-04 669
一 ThreadPool package concurrent.threadpool; /** * @className: ThreadPool * @description: 线程池接口 * @date: 2022/4/2 * @author: cakin */ public interface ThreadPool { // 提交任务到线程池 void execute(Runnable runnable); // 关闭线程池 void shutdown();
smart Java——线程池实战（线程实现方式、ThreadPoolExecutor、线程池分类及实战、周期定时任务ScheduledThreadPoolExecutor）
TracyCoder的博客
06-14 454
保证下层的实现只需关注一个执行任务的方法即可。
C++项目实战--线程池代码讲解
weixin_46120107的博客
09-01 1254
使用线程池可以减少线程的销毁，而且如果不使用线程池的话，来一个客户端就创建一个线程。比如有1000，这样线程的创建、线程之间的调度也会耗费很多的系统资源，所以采用线程池使程序的效率更高。线程池就是项目启动的时候，就先把线程池准备好。通过while不断让工作线程的请求工作队列，如果工作队列不为空，则获取一个任务并处理。将互斥锁、条件变量、线程池是否关闭的状态、工作队列封装到一起，然后通过智能指针(共享的)来操作管理这些条件。这段代码是通过c++14写的，我们主要看逻辑关系和实现的原理。
线程池多线程在项目中的实际应用
最新发布
The best are water的博客
04-22 866
线程、线程池在项目中的实际应用
Spring Boot 实战：@Async 异步处理与线程池配置解析
在Java项目开发中，特别是在Spring Boot框架中，为了提高系统的并发处理能力，我们常常会使用线程池来管理后台任务。Spring Boot提供了便捷的方式来创建和配置线程池，同时支持使用`@Async`注解实现异步执行任务。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值