spring-线程池（1）

多线程并发处理起来一般比较麻烦，若是你使用spring容器来管理业务bean，事情就好办了多了。spring封装了java的多线程的实现，你只须要关注于并发事物的流程以及一些并发负载量等特性，具体来讲如何使用spring来处理并发事务：

1.了解 TaskExecutor接口

Spring的 TaskExecutor接口等同于java.util.concurrent.Executor接口。 实际上，它存在的主要缘由是为了在使用线程池的时候，将对Java 5的依赖抽象出来。 这个接口只有一个方法execute(Runnable task)，它根据线程池的语义和配置，来接受一个执行任务。最初建立TaskExecutor是为了在须要时给其余Spring组件提供一个线程池的抽 象。 例如ApplicationEventMulticaster组件、JMS的 AbstractMessageListenerContainer和对Quartz的整合都使用了TaskExecutor抽象来提供线程池。 固然，若是你的bean须要线程池行为，你也可使用这个抽象层。

2. TaskExecutor接口的实现类

(1)SimpleAsyncTaskExecutor 类

这个实现不重用任何线程，或者说它每次调用都启动一个新线程。可是，它仍是支持对并发总数设限，当超过线程并发总数限制时，阻塞新的调用，直到有位置被释放。若是你须要真正的池，请继续往下看。

(2)SyncTaskExecutor类

这个实现不会异步执行。相反，每次调用都在发起调用的线程中执行。它的主要用处是在不须要多线程的时候，好比简单的test case。

(3)ConcurrentTaskExecutor 类

这个实现是对 Java 5 java.util.concurrent.Executor类的包装。有另外一个备选, ThreadPoolTaskExecutor类，它暴露了Executor的配置参数做为bean属性。不多须要使用 ConcurrentTaskExecutor, 可是若是ThreadPoolTaskExecutor不敷所需，ConcurrentTaskExecutor是另一个备选。

(4)SimpleThreadPoolTaskExecutor 类

这个实现其实是Quartz的SimpleThreadPool类的子类，它会监听Spring的生命周期回调。当你有线程池，须要在Quartz和非Quartz组件中共用时，这是它的典型用处。

(5)ThreadPoolTaskExecutor 类

它不支持任何对 java.util.concurrent包的替换或者下行移植。Doug Lea和Dawid Kurzyniec对java.util.concurrent的实现都采用了不一样的包结构，致使它们没法正确运行。 这个实现只能在Java 5环境中使用，可是倒是这个环境中最经常使用的。它暴露的bean properties能够用来配置一个java.util.concurrent.ThreadPoolExecutor，把它包装到一个 TaskExecutor中。若是你须要更加先进的类，好比ScheduledThreadPoolExecutor,咱们建议你使用 ConcurrentTaskExecutor来替代。

(6)TimerTaskExecutor类

这个实现使用一个TimerTask做为其背后的实现。它和SyncTaskExecutor的不一样在于，方法调用是在一个独立的线程中进行的，虽然在那个线程中是同步的。

(7)WorkManagerTaskExecutor类

这个实现使用了 CommonJ WorkManager做为其底层实现，是在Spring context中配置CommonJ WorkManager应用的最重要的类。和SimpleThreadPoolTaskExecutor相似，这个类实现了WorkManager接口， 所以能够直接做为WorkManager使用。 

 

3. 简单hellword

 

3.1 线程类

public class MessagePrinterTask implements Runnable {
    private String message;

    public MessagePrinterTask() {

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

    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(message);
    }
}

 

3.1 线程管理工具类

import org.springframework.core.task.TaskExecutor;

public class TaskExecutorUtil {
    
    private TaskExecutor taskExecutor;
    public TaskExecutor getTaskExecutor() {
        return taskExecutor;
    }

    public void setTaskExecutor(TaskExecutor taskExecutor) {
        this.taskExecutor = taskExecutor;
    }

    public void printMessages(Runnable r,int i) {
            taskExecutor.execute(r);
            System.out.println("add Thread："+i);
    }


}

 

applicationContext.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.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="2" />  
    <!-- 最大线程数 -->  
    <property name="maxPoolSize" value="3" />  
    <!-- 队列最大长度 >=mainExecutor.maxSize -->  
    <property name="queueCapacity" value="10" />  
    <!-- 线程池维护线程所容许的空闲时间 -->  
    <property name="keepAliveSeconds" value="300" />  
    <!-- 线程池对拒绝任务(无线程可用)的处理
    策略 --> <!-- 若不做该处理，当线程满了，队列满了以后，继续往下增长任务，则抛出异常，拒绝该任务 --> 
    <property name="rejectedExecutionHandler">  
      <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />  
    </property>
</bean>
  
<bean id="taskExecutorUtil" class="TaskExecutorUtil">    
    <!-- <constructor-arg ref="taskExecutor" />  --> 
    <property name="taskExecutor" ref="taskExecutor" /> 
</bean> 

<!-- 托管线程 -->
<bean id="messagePrinterTask" class="MessagePrinterTask">    
</bean> 

  
  
</beans>

 

测试

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext.xml");    
        TaskExecutorUtil te = (TaskExecutorUtil)appContext.getBean("taskExecutorUtil");   
        
        for (int i = 0; i < 25; i++) {
            MessagePrinterTask m=new MessagePrinterTask("Message" + i);
            te.printMessages(m,i); 
        } 
        System.out.println("11111111111111111111111"); 
    }
}

结果输出

add Thread：0
add Thread：1
add Thread：2
add Thread：3
add Thread：4
add Thread：5
add Thread：6
add Thread：7
add Thread：8
add Thread：9
add Thread：10
add Thread：11
add Thread：12
Message1
Message0
Message13
add Thread：13
Message12
add Thread：14
add Thread：15
add Thread：16
Message2
Message4
Message17
add Thread：17
Message3
add Thread：18
add Thread：19
add Thread：20
Message5
Message7
Message21
add Thread：21
Message6
add Thread：22
add Thread：23
add Thread：24
11111111111111111111111
Message9
Message8
Message10
Message14
Message15
Message11
Message18
Message19
Message16
Message22
Message23
Message20
Message24

 

解释：

1.由于线程类睡眠5秒，因此在5秒前add Thread增长了13个线程(3个最大线程+10个在队列中等候)，因为在作了对了满了的策略（rejectedExecutionHandler），因此不会抛出异常，

其余线程等候加入队列

2.五秒后打印，而后继续addThread，打印message，注意当前最大线程执行是3个，，其他在队列等候，而后打印剩余线程，111111111111是主线程

 

 

四、配置解释
当一个任务经过execute(Runnable)方法欲添加到线程池时：
一、 若是此时线程池中的数量小于corePoolSize，即便线程池中的线程都处于空闲状态，也要建立新的线程来处理被添加的任务。
二、 若是此时线程池中的数量等于 corePoolSize，可是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
三、若是此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，而且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
四、 若是此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，而且线程池中的数量等于maximumPoolSize，那么经过 handler所指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程 maximumPoolSize，若是三者都满了，使用handler处理被拒绝的任务。
五、 当线程池中的线程数量大于 corePoolSize时，若是某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池能够动态的调整池中的线程数。

 

 

 

 

5. 线程类为 java.util.concurrent.ThreadPoolExecutor：

线程池类为 java.util.concurrent.ThreadPoolExecutor，经常使用构造方法为：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)

corePoolSize： 线程池维护线程的最少数量
maximumPoolSize：线程池维护线程的最大数量
keepAliveTime： 线程池维护线程所容许的空闲时间
unit： 线程池维护线程所容许的空闲时间的单位
workQueue： 线程池所使用的缓冲队列
handler： 线程池对拒绝任务的处理策略

一个任务经过 execute(Runnable)方法被添加到线程池，任务就是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。

当一个任务经过execute(Runnable)方法欲添加到线程池时：

若是此时线程池中的数量小于corePoolSize，即便线程池中的线程都处于空闲状态，也要建立新的线程来处理被添加的任务。

若是此时线程池中的数量等于 corePoolSize，可是缓冲队列 workQueue未满，那么任务被放入缓冲队列。

若是此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，而且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。

若是此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，而且线程池中的数量等于maximumPoolSize，那么经过 handler所指定的策略来处理此任务。

也就是：处理任务的优先级为：
核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，若是三者都满了，使用handler处理被拒绝的任务。

当线程池中的线程数量大于 corePoolSize时，若是某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池能够动态的调整池中的线程数。

unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。

workQueue我经常使用的是：java.util.concurrent.ArrayBlockingQueue

handler有四个选择：
ThreadPoolExecutor.AbortPolicy()
抛出java.util.concurrent.RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy()
重试添加当前的任务，他会自动重复调用execute()方法
ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务