1.1 Spring 线程池 --- ThreadPoolTaskExecutor

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