Spring 结合线程池实现 三种例子 注解应用 细品

 

包：spring的包都加上：

 

 

例子一：

用@Component让Spring容器管理此线程，Bean的范围必须是prototype，因此每个请求都会返回一个新实例，运行每个单独的线程

package com.adao.spring.config;

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

public class App1 {
    static ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
    public static void main(String[] args) {
        
        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();
    }
}

package com.adao.spring.config;

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

@Configuration  
@ComponentScan(basePackages="com.adao.spring.config")  
public class AppConfig {  
} 

package com.adao.spring.config;

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

执行结果：

 

 

例子二： XML配置形式的线程池

Spring-Config.xml：

<?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.1.xsd  
        http://www.springframework.org/schema/context  
        http://www.springframework.org/schema/context/spring-context-3.1.xsd">

    <!-- 包路径扫描 -->
    <context:component-scan base-package="com.adao.spring.xmlconfig" />

    <!-- Spring线程池 -->
    <bean id="taskExecutor"
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!-- 核心线程数 -->
        <property name="corePoolSize" value="5" />
        <!-- 线程池维护线程的最大数量 -->
        <property name="maxPoolSize" value="10" />
        <!-- 允许的空闲时间, 默认60秒 -->
        <property name="keepAliveSeconds" value="60" />
        <!-- 任务队列 -->
        <property name="queueCapacity" value="50" />
        <!-- 线程超过空闲时间限制，均会退出直到线程数量为0 -->
        <property name="allowCoreThreadTimeOut" value="true" />
        <property name="WaitForTasksToCompleteOnShutdown"
            value="true" />
        <!-- 对拒绝task的处理策略 -->
        <property name="rejectedExecutionHandler">
            <bean class="java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy" />
        </property>
    </bean>

</beans>  

package com.adao.spring.xmlconfig;

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

public class App2 {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("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;
            }
        }
    }

}

package com.adao.spring.xmlconfig;
// runnable形式
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线程池结果Bean

package com.adao.spring.bean;

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

public class App3 {
    static ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
    public static void main(String[] args) {
        
        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;
            }
        }
    }

}

package com.adao.spring.bean;

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.adao.spring.bean")  
public class AppConfig {  
        @Bean  
        public ThreadPoolTaskExecutor taskExecutor(){  
                ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();  
                pool.setCorePoolSize(5);  
                pool.setMaxPoolSize(10);  
                pool.setWaitForTasksToCompleteOnShutdown(true);  
                return pool;  
        }  
} 

package com.adao.spring.bean;

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

执行结果：