Spring中线程池的用法

Posted 2022-12-14 Bwz_Learning

多线程并发处理起来通常比较麻烦，如果你使用spring容器来管理业务bean，事情就好办了多了。spring封装了java的多线程的实现，简化了开发。

简单的Hello程序

需要执行的线程类

一般是对于业务的封装.将具体的业务逻辑放到，线程内执行。

public class MessagePrinterTask implements Runnable 
    private String message;

    public MessagePrinterTask() 

    

    public MessagePrinterTask(String message) 
        this.message = message;
    

    public void run() 
        try 
            Thread.sleep(3000);
            System.out.println(message);
         catch (InterruptedException e) 
            e.printStackTrace();
        

    

    @Override
    public String toString() 
        return "MessagePrinterTask [message=" + message + "]";
    

spring 的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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.0.xsd  
http://www.springframework.org/schema/context                
http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- 异步线程池 -->
    <bean id="taskExecutor"
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!-- 核心线程数 -->
        <property name="corePoolSize" value="10" />
        <!-- 最大线程数 -->
        <property name="maxPoolSize" value="50" />
        <!-- 队列最大长度 >=mainExecutor.maxSize -->
        <property name="queueCapacity" value="100" />
        <!-- 线程池维护线程所允许的空闲时间 -->
        <property name="keepAliveSeconds" value="300" />
        <!-- 线程池对拒绝任务(无线程可用)的处理 策略 -->
        <!-- 若不作该处理，当线程满了，队列满了之后，继续往下增加任务，则抛出异常，拒绝该任务 -->
        <!-- <property name="rejectedExecutionHandler"> <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" /> </property> -->
    </bean>

    <!-- 处理业务的线程 -->
    <bean id="messagePrinterTask" class="com.test.sping.thread.MessagePrinterTask" />

</beans>

测试代码

• 测试代码

import java.util.concurrent.Executor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ThreadTest 
    public static void main(String[] args) 

        ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Executor executor = (Executor) appContext.getBean("taskExecutor");

        for (int i = 0; i < 10; i++) 
            MessagePrinterTask mTask = new MessagePrinterTask("Message data  is " + i);
            executor.execute(mTask);
        

        System.out.println("I am from Main Thread ...");
    

• 测试代码的运行结果

I am from Main Thread ...
Message data  is 5
Message data  is 7
Message data  is 6
Message data  is 8
Message data  is 4
Message data  is 9
Message data  is 0
Message data  is 3
Message data  is 1
Message data  is 2

在Spring容器启动的时候,启动一个线程

spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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.0.xsd  
http://www.springframework.org/schema/context                
http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- 执行业务方法的线程 -->
    <bean id="scheduledThread" class="com.test.sping.thread.ScheduledThread" />

    <!-- 这样设置容器一启动就自动运行某个线程 start -->
    <bean id="springScheduleExecutorTask" class="org.springframework.scheduling.concurrent.ScheduledExecutorTask">
        <!-- messagePrinterTask为线程类 -->
        <property name="runnable" ref="scheduledThread" />
        <!-- 容器加载5秒后开始执行 -->
        <property name="delay" value="5000" />
        <!-- 每次任务间隔 2秒，循环执行该线程，删除该设定就容器启动后只执行一次 -->
        <property name="period" value="2000" />
    </bean>

   <!-- 这样设置容器一启动就自动运行某个线程  -->
    <bean id="springScheduledExecutorFactoryBean" class="org.springframework.scheduling.concurrent.ScheduledExecutorFactoryBean">
        <property name="scheduledExecutorTasks">
            <list>
                <ref bean="springScheduleExecutorTask" />
            </list>
        </property>
    </bean>


</beans>

业务线程

public class ScheduledThread implements Runnable 

    @Override
    public void run() 

        while (true) 
            try 
                Thread.sleep(5000);
                System.out.println(" I am from ScheduledThread ...");
             catch (InterruptedException e) 
                e.printStackTrace();
            
        
    

测试代码

import org.springframework.context.support.ClassPathXmlApplicationContext;
public class ScheduledThreadTest 
    public static void main(String[] args) 

        ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext-scheduled.xml");

        try 
            Thread.sleep(Integer.MAX_VALUE);
         catch (InterruptedException e) 
            e.printStackTrace();