Spring和Java线程示例

最新推荐文章于 2024-01-16 17:19:10 发布
最新推荐文章于 2024-01-16 17:19:10 发布
阅读量96 收藏
点赞数
文章标签： java
Java thread images

这里有3个示例，向您展示如何在Spring中进行“ 线程化 ”。 请参阅代码以进行自我解释。

1. Spring + Java Threads示例

通过扩展Thread创建一个简单的Java线程，并由Spring的容器通过@Component 。 bean范围必须是“ prototype ”，以便每个请求将返回一个新实例，以运行每个单独的线程。

PrintThread.java 
package com.mkyong.thread;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@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");
	}

}
AppConfig.java 
package com.mkyong.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages="com.mkyong.thread")
public class AppConfig{
}
App.java 
package com.mkyong;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.mkyong.config.AppConfig;
import com.mkyong.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 3 is running
Thread 2 is running
Thread 1 is running
Thread 5 is running
Thread 4 is running
Thread 2 is running
Thread 4 is running
Thread 5 is running
Thread 3 is running
Thread 1 is running

2. Spring Thread Pool + Spring非托管Bean示例

使用Spring的ThreadPoolTaskExecutor创建线程池。 Spring容器不必管理执行线程。

PrintThread.java – This thread is not managed by Spring, NO @Component 
package com.mkyong.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");
	}

}
Spring-Config.xml – ThreadPoolTaskExecutor in XML file 
<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>
App.java 
package com.mkyong;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import com.mkyong.thread.PrintTask;

public class App {
  public static void main(String[] args) {

    ApplicationContext context = new ClassPathXmlApplicationContext("Spring-Config.xml");
    ThreadPoolTaskExecutor taskExecutor = (ThreadPoolTaskExecutor) context.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"));

	//check active thread, if zero then shut down the thread pool
	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
Thread 2 is running
Thread 1 is running
Thread 3 is running
Thread 4 is running
Thread 5 is running
Active Threads : 0

3. Spring线程池+ Spring托管Bean示例

这个示例再次使用ThreadPoolTaskExecutor ，并通过@Component将线程声明为Spring托管bean。

下面的PrintTask2是Spring托管的bean，您可以轻松地@Autowired任何必需的bean。

PrintTask2.java 
package com.mkyong.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");

	}

}
AppConfig.java – ThreadPoolTaskExecutor in Spring configuration file 
package com.mkyong.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.mkyong.thread")
public class AppConfig {

	@Bean
	public ThreadPoolTaskExecutor taskExecutor() {
		ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();
		pool.setCorePoolSize(5);
		pool.setMaxPoolSize(10);
		pool.setWaitForTasksToCompleteOnShutdown(true);
		return pool;
	}

}
App.java 
package com.mkyong;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import com.mkyong.config.AppConfig;
import com.mkyong.thread.PrintTask2;

public class App {
  public static void main(String[] args) {
		
    ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    ThreadPoolTaskExecutor taskExecutor = (ThreadPoolTaskExecutor) context.getBean("taskExecutor");

    PrintTask2 printTask1 = (PrintTask2) context.getBean("printTask2");
    printTask1.setName("Thread 1");
    taskExecutor.execute(printTask1);

    PrintTask2 printTask2 = (PrintTask2) context.getBean("printTask2");
    printTask2.setName("Thread 2");
    taskExecutor.execute(printTask2);

    PrintTask2 printTask3 = (PrintTask2) context.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
Thread 3 is running
Active Threads : 2
Active Threads : 3
Active Threads : 3
Active Threads : 3
Active Threads : 3
Thread 1 is running
Thread 3 is running
Thread 2 is running
Active Threads : 0

喜欢您的意见，以改善上述程序。

下载源代码

下载它– Spring-Thread-Example.zip （22 KB）

参考文献

  1. Spring调度参考
  2. ThreadPoolTask​​Executor JavaDoc
  3. 在Spring配置文件中声明bean
  4. 如何关闭Spring任务执行程序/调度程序池
  5. Spring并发示例
标签：

翻译自: https://mkyong.com/spring/spring-and-java-thread-example/

cyan20115
关注
探索Spring虚拟线程：高效并发编程的新选择
fudaihb的博客
06-14 1562
随着现代应用程序的复杂性不断增加，处理高并发和高性能需求变得至关重要。Java作为一种广泛使用的编程语言，一直在不断进化以应对这些挑战。Spring框架作为Java生态系统中最流行的框架之一，也在积极适应这些变化。本文将深入探讨Spring中的虚拟线程（Virtual Threads），它们如何工作以及如何利用它们来提升应用程序的并发性能。
Spring的多线程应用
09-02
一个简单的spring的多线程demo，希望能对大家有用
Spring线程池开发实战
l192168134的博客
05-03 1066
Spring线程池开发实战 作者：chszs，转载需注明。 作者博客主页：http://blog.csdn.net/chszs 本文提供了三个Spring多线程开发的例子，由浅入深，由于例子一目了然，所以并未做过多的解释。诸位一看便知。 前提条件： 1）在Eclipse创建一个Java项目，我取名为SpringThreadDemo。 2）项目所需的JAR包如图所示：  
9-Spring_Thread-1
javabcdef的博客
03-28 144
1.resume from break point IO integration 2.thread create { 1.extends Thread,and override the run(){ } thread.run() & thread .start(),they are not the same } 3.2ways to use the thread ...
spring 使用 thread（多线程）
孙海东的博客
03-08 1240
spring 使用 thread（多线程） ​ 在Java项目中，多线程的使用是非常普遍的；例如：当具体的业务实现后，一边需要返回给前端，一边又需要添加到日志表中，如果等添加到日志表中之后再返回前端，就浪费时间；这时就需要多线程来处理！ 1。定义配置类（ThreadConfig） package com.sun.config; import lombok.extern.slf4j.Slf4j; import org.springframework.aop.interceptor.AsyncUncaugh
SPRING Thread开发实战
weixin_34194317的博客
09-02 170
SPRING Thread开发实战 1. 加入配置 1. <bean id="threadPool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"> 2. <!-- 核心线程数 --> 3. &l...
java-demo:其他Java和Spring示例
04-04
"java-demo:其他Java和Spring示例"这个项目，显然旨在提供一系列示例代码，帮助开发者理解和掌握Java以及Spring框架的各种功能和用法。下面将详细探讨其中可能涉及的知识点。 1. **Java基础**：作为标签为"Java"的...
spring单例引起的线程安全问题
12-21
在 Spring 框架中，bean 的实例化策略分为两种：单例（Singleton）和多例（Prototype）。单例模式意味着在整个 Spring 容器中，对于一个给定的 bean 定义，只会存在一个实例。这通常通过 @Scope("singleton") 注解来...
实例讲解spring boot 多线程
08-18
本文主要介绍了 Spring Boot 中多线程的实现，通过示例代码详细讲解了如何使用 TaskExecutor 来实现多线程和并发编程。同时，我们还将介绍如何使用 @EnableAsync 注解开启异步任务支持，并在实际执行的 Bean 的方法...
Java Spring多线程demo代码
10-30
在"Java Spring多线程demo代码"中，可能包含使用`@Async`和`@Scheduled`注解的示例，以及如何配置和自定义`ThreadPoolTaskExecutor`和`ThreadPoolTaskScheduler`的代码。通过这些示例，你可以学习到如何在Spring应用...
spring与ThreadLocal
黎明踏浪的专栏
03-15 517
今天遇到一个问题：使用tomcat做服务器，两个请求中的线程本地变量是同一个对象。 我的理解是这样的，spring启动的时候会帮我们组装bean，它是在同一个线程中完成的，所以如果一个bean的属性是ThreadLocal，那么将会被赋予当前线程的对象，这样就会造成我们在不同的请求中获取的线程变量是同一个对象。如果有什么不对的地方，希望大家指正。
spring 多线程
流沙-岁月
08-02 398
线程池： corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建coreP
spring（用ThreadPoolTaskExecutor简单实现线程池）
qq_28829553的博客
04-18 756
话不多说直接上步骤 1.在spring.xml配置线程池bean <bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"> <!-- 核心线程数 --> <property name="corePoolSize" value...
一文了解Spring线程池(超详细+干货满满)
最新发布
adobe754的博客
01-16 1842
一文了解Spring线程池(超详细+干货满满)
Spring Thread Pool 线程池的应用
weixin_30848775的博客
04-12 72
Spring and Java Thread example 扫扫关注“茶爸爸”微信公众号 坚持最初的执着，从不曾有半点懈怠，为优秀而努力，为证明自己而活。 Download it – Spring-Thread-Example.zip (22 KB) 转自：http://www.mkyong.com/spring/...
spring框架整合遇到的thread配置问题
qq_37693957的博客
08-01 176
这个问题困扰了我好几天，最开始配置如下 上面
Spring线程池ThreadPoolTaskExecutor的使用
上善若泪
12-29 4万+
文章目录1 简介2 示例2.1 线程池配置类2.2 异步方法2.3 启动测试 1 简介 Spring 通过任务执行器（TaskExecutor）来实现多线程和并发编程，使用ThreadPoolTaskExecutor实现一个基于线程池的TaskExecutor， 还得需要使用@EnableAsync开启异步，并通过在需要的异步方法那里使用注解@Async声明是一个异步任务 Spring 已经实现的异常线程池： SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创
史上最全的java spring注解，没有之一
热门推荐
陈袁的博客
05-27 6万+
注解是个好东西，但好东西我们也是看见过，整理过，理解过，用过才知道好。不求我们每个都记住，但求保有印象，在需要的时候能提取出来再查找相关资料，平时工作就不会显得那么被动了。1.@Configuration注解该类等价 与XML中配置beans，相当于Ioc容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean，与xml中配置的bean意思一样。@Configurati...
Spring 多线程
xiaolyuh的专栏
03-17 4461
Spring 通过任务执行器（TaskExecutor）来实现多线程和并发编程。使用ThreadPoolTaskExecutor可以实现一个基于线程池的TaskExecutor。而实际上开发中的任务一般是非阻塞的，即异步的，所以我们要在配置类中通过@EnableAsync注解来开启对异步任务的支持，并通过在实际执行的Bean的方法上使用@Async注解来声明一个异步任务。 配置类： p
Java Spring Boot 开源项目示例
通过这些代码片段，我们可以了解到这个Java开源项目是如何使用Spring Boot构建服务，并且处理网络请求，以及如何利用并发和日志工具来提高效率和可维护性。同时，这也提供了一个学习和参考的平台，帮助开发者了解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值