Spring 擅长对组件的封装和集成, Spring-context对JDK的并发包做了功能增强。
step 1 :Spring-context.xml 中增加如下代码
<bean id="poolTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<!-- 核心线程数,默认为1 -->
<property name="corePoolSize" value="5" />
<!-- 最大线程数,默认为Integer.MAX_VALUE -->
<property name="maxPoolSize" value="50" />
<!-- 队列最大长度,一般需要设置值>=notifyScheduledMainExecutor.maxNum;默认为Integer.MAX_VALUE -->
<property name="queueCapacity" value="2000" />
<!-- 线程池维护线程所允许的空闲时间,默认为60s -->
<property name="keepAliveSeconds" value="100" />
<!-- 线程池对拒绝任务(无线程可用)的处理策略,目前只支持AbortPolicy、CallerRunsPolicy;默认为后者 -->
<property name="rejectedExecutionHandler">
<!-- AbortPolicy:直接抛出java.util.concurrent.RejectedExecutionException异常 -->
<!-- CallerRunsPolicy:主线程直接执行该任务,执行完之后尝试添加下一个任务到线程池中,可以有效降低向线程池内添加任务的速度 -->
<!-- DiscardOldestPolicy:抛弃旧的任务、暂不支持;会导致被丢弃的任务无法再次被执行 -->
<!-- DiscardPolicy:抛弃当前任务、暂不支持;会导致被丢弃的任务无法再次被执行 -->
<bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
</property>
</bean>
step 2 :线程池使用
申明和使用
代码
@Autowired
@Qualifier(value = "poolTaskExecutor")
private ThreadPoolTaskExecutor threadPoolTaskExecutor;
@RequestMapping(value = "Info", method = RequestMethod.POST)
public String passerbyInfo(@RequestBody String json) {
threadPoolTaskExecutor.execute(new Runnable() {
@Override
public void run() {
log.info("-----开启线程-----");
// Todo
}
});
return json;
}
以上asyncTaskExecutor,你可以注入到任何一个bean去执行,底层使用JDK的ThreadPoolTaskExecutor来管理线程,默认使用的是JDK的线程池.
以上只是简单的应用,非常方便的开发,我们都不用去处理线程池的初始化,以及线程的管理。
功能 1 :Spring 对线程的监听--成功 / 失败
ListenableFutureTask<String> f1 = (ListenableFutureTask<String>) asyncTaskExecutor.submitListenable(c1);
f1.addCallback(new ListenableFutureCallback<String>() {
@Override
public void onSuccess(String result) {
//成功时 TODO
}
@Override
public void onFailure(Throwable t) {
// 失败时 TODO Auto-generated method stub
t.printStackTrace();
}
});
功能 2 :扩展FutureTask的protected方法
package org.springframework.util.concurrent;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ListenableFutureTask<T> extends FutureTask<T> implements ListenableFuture<T> {
private final ListenableFutureCallbackRegistry<T> callbacks = new ListenableFutureCallbackRegistry<T>();
/**
* Create a new {@code ListenableFutureTask} that will, upon running,
* execute the given {@link Callable}.
* @param callable the callable task
*/
public ListenableFutureTask(Callable<T> callable) {
super(callable);
}
/**
* Create a {@code ListenableFutureTask} that will, upon running,
* execute the given {@link Runnable}, and arrange that {@link #get()}
* will return the given result on successful completion.
* @param runnable the runnable task
* @param result the result to return on successful completion
*/
public ListenableFutureTask(Runnable runnable, T result) {
super(runnable, result);
}
@Override
public void addCallback(ListenableFutureCallback<? super T> callback) {
this.callbacks.addCallback(callback);
}
@Override
protected final void done() {
Throwable cause;
try {
T result = get();
this.callbacks.success(result);
return;
}
catch (InterruptedException ex) {
Thread.currentThread().interrupt();
return;
}
catch (ExecutionException ex) {
cause = ex.getCause();
if (cause == null) {
cause = ex;
}
}
catch (Throwable ex) {
cause = ex;
}
this.callbacks.failure(cause);
}
}