spring-线程池（1）

最新推荐文章于 2024-11-12 21:14:07 发布

机械师

最新推荐文章于 2024-11-12 21:14:07 发布

阅读量546

点赞数

分类专栏： Java 文章标签： java 线程池 spring

Java 专栏收录该内容

36 篇文章 1 订阅

订阅专栏

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是主线程

4、配置解释
当一个任务通过execute(Runnable)方法欲添加到线程池时：
1、如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
2、如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
3、如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
4、如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程 maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。
5、当线程池中的线程数量大于 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()
抛弃当前的任务