Spring线程池开发实战

最新推荐文章于 2024-10-08 21:51:52 发布
最新推荐文章于 2024-10-08 21:51:52 发布
阅读量7k 收藏 2
点赞数 6
分类专栏： ssh 多线程

作者：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


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


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框架在多线程方面的强大之处！！



demo下载地址



静静～嗯嗯
关注
专栏目录
Spring的多线程
实践求真知
08-10 1万+
一 点睛 Spring通过任务执行器（TaskExecutor）来实现多线程和并发编程。 使用ThreadPoolTaskExecutor可实现一个基于线程池的TaskExecutor。 实际开发中一般是非阻塞的，即异步的，所以我们要在配置类中通过@EnableAsync开启对异步任务的支持，并通过在实际执行的Bean的方法中使用@Async注解来声明其是一个异步任务。 二 ThreadP...
10年IT老兵亲述SpringCloud开发从入门到实战文档
ma_xiao_qi的博客
06-13 641
java学习 成长思维导图：骆驼祥子思维导图 - GitMind首先给大家看一张图，不知道图上这些springcloud的技术知识点，大家是否都精通而灵活运用了呢？ 如果没有精通灵活运用的话，小编将用此文来带大家一步步来深入学习这些技术知识，接下来将从Spring Boot微框架搭建、Spring Cloud常用组件应用，到微服务案例实战，层层剥茧式分析，全流程讲解Spring Cloud开发应用，实战案例拿来就用，带大家快速上手。本文主要分为21章的内容给大家介绍springcloud开发从入门到实战，大
Spring异步线程池的问题
最新发布
qq_42704130的博客
10-08 1026
尽管Spring Boot提供了默认的线程池配置，但在实际应用中，根据业务需求和系统负载，这些默认配置可能需要调整。开发者可以通过在或文件中添加相应的配置属性来自定义线程池的行为。
Spring 线程池
jijl
10-24 856
一、java配置 @Configuration @EnableAsync public class AsyncConfig { /* 此处成员变量应该使用@Value从配置中读取 */ private int corePoolSize = 10; private int maxPoolSize = 200; private int queueC...
spring线程池
八荒六合唯我独尊
08-03 197
1. xml配置 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.
Spring注解驱动开发实战-servlet
02-16
本实战指南将深入探讨如何利用Spring的注解来实现高效、灵活的Servlet容器集成。 首先，让我们来理解`ServletContainerInitializer`。这是一个Java EE 7引入的接口，允许我们自定义初始化Servlet容器的行为。通过...
Java线程池与Web整合开发实战教程
通过上述知识点的详细解析，初级编程者可以系统地掌握Java编程、数据库操作、线程池管理以及Java Web开发的相关技能，并通过实战案例的学习提高解决实际问题的能力。这套资料适合初学者入门和巩固Java基础，帮助他们...
微服务开发(五) Spring Cloud 开发综合案例实践(一)
柳老师的博客
07-29 1080
项目架构的设计就像建一栋楼盘的图纸一样非常的重要,如果你是搭一间二层楼的房子,这个图纸的重要性可能不大,但是如果你是用Spring Cloud做开发,显然这将会是一栋30多层的建筑,如果图纸设计错误,造成的后果可能就是推倒重来,所以,项目前期的架构设计非常的重要,我尝试用一张图来描述这个项目的架构.
Spring-线程池
06-05 391
之前在Springboot学习笔记（一）-线程池的简化及使用中介绍了异步执行的用法, 这在Spring中也是适用的, 本文在其基础上新增几点说明: ThreadPoolTaskExecutor在提交完任务后不能直接shutdown()–这与ThreadPoolExecutor不同-- 否则会导致后续任务无法提交, 因为在Spring环境下, 为了节省资源, 一般都是共享一个执行器(比如@Async的执行原理), 也就是说它是单例的, 如果确定只执行一次, 可以调用setWaitForTasksToComp
spring 线程池
04-23
NULL 博文链接：https://hoochiang.iteye.com/blog/2249733
Spring线程池
endlesslin的专栏
03-14 122
了解TaskExecutor接口 当创建了一个新的 Configuration 对象时，它使用一个 maxStrongSize 值为 0 的 MruCacheStorage 缓存来 初 始 化 ， maxSoftSize 的值是 Integer.MAX_VALUE（也就是说在实际中， 是无限大 的）。但是使用 非 0 的 maxStrongSize 对于高负载的服务器来说也许是一个更好的策...
Spring中的线程池ThreadPoolTaskExecutor介绍
weixin_33882452的博客
12-16 892
前言： Java SE 5.0引入了ThreadPoolExecutor、ScheduledThreadPoolExecutor。Spring 2.x借助ConcurrentTaskExecutor和ThreadPoolTaskExecutor能够通过IoC配置形式自定义它们暴露的各个属性。 多线程并发处理起来通常比较麻烦，如果你使用spring容器来管理业务bean，事情就好办了多了。spr...
spring中的线程池
m0_37609060的博客
01-15 173
spring: task: execution: pool: core-size:10 max-size: 300 queue-capacity: 256 keep-alive: 600000 thread-name-prefix: db-service-task- core-size 表示当线程池中的线程数量没有达到core-size时，没来一个事物，那么创建一个新的线程放入线程池中 当再来一个线程，而且线程池中没有空闲的线程时，将新的线程放入queue-capacity中，知道queue-capacit
Spring 线程池应用
来者是客
09-26 317
1.了解 TaskExecutor接口     Spring的TaskExecutor接口等同于java.util.concurrent.Executor接口。 实际上，它存在的主要原因是为了在使用线程池的时候，将对Java 5的依赖抽象出来。 这个接口只有一个方法execute(Runnable task)，它根据线程池的语义和配置，来接受一个执行任务。最初创建TaskExecutor是为了在...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值