Spring线程池

出处：http://www.blogjava.net/paulwong/archive/2011/12/07/365773.html（如存在版权问题，请与我联，系，会马上删除）

用ThreadPoolExecutor的时候，又想知道被执行的任务的执行情况，这时就可以用FutureTask。
ThreadPoolTask
package com.paul.threadPool;
import java.io.Serializable;
import java.util.concurrent.Callable;
public class ThreadPoolTask implements Callable, Serializable {
    private static final long serialVersionUID = 0;
      
    // 保存任务所需要的数据
    private Object threadPoolTaskData;
    private static int consumeTaskSleepTime = 2000;
    public ThreadPoolTask(Object tasks) {
        this.threadPoolTaskData = tasks;
    }
    public synchronized String call() throws Exception {
        // 处理一个任务，这里的处理方式太简单了，仅仅是一个打印语句
        System.out.println("开始执行任务：" + threadPoolTaskData);
        String result = "";
        // //便于观察，等待一段时间
        try {
//            long r = 5/0;
            for ( int  i= 0 ; i< 100000000 ; i++){  
                  
            }
            result = "OK";
        } catch (Exception e) {
            e.printStackTrace();
            result = "ERROR";
        }
        threadPoolTaskData = null;
        return result;
    }
}
模拟客户端提交的线程
package com.paul.threadPool;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
public class StartTaskThread implements Runnable{
 private ThreadPoolTaskExecutor threadPoolTaskExecutor;
 private int i;
   
 public StartTaskThread(ThreadPoolTaskExecutor threadPoolTaskExecutor,int i)
 {
 this.threadPoolTaskExecutor = threadPoolTaskExecutor;
 this.i = i;
 }
   
 @Override
 public synchronized void run() {
 String task = "task@ " + i;
 System.out.println("创建任务并提交到线程池中：" + task);
 FutureTask futureTask = new FutureTask(
 new ThreadPoolTask(task));
 threadPoolTaskExecutor.execute(futureTask);
 // 在这里可以做别的任何事情
 String result = null;
 try {
 // 取得结果，同时设置超时执行时间为0.1秒。同样可以用future.get()，不设置执行超时时间取得结果
 result = futureTask.get();
   
 } catch (InterruptedException e) {
 futureTask.cancel(true);
 } catch (ExecutionException e) {
 futureTask.cancel(true);
 } catch (Exception e) {
 futureTask.cancel(true);
 // 超时后，进行相应处理
 } finally {
 System.out.println("task@" + i + ":result=" + result);
 }
}
SPRING配置文件


 
 
 
 
 
 
   
 
 
 
 
 
   
 
 
 
 
 
   
 
 
   
 
 
   
 
 
   
 
   
 
 
   
 
 
 
 
 
 
 
 
 
   

测试类
package com.paul.threadPool;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
@ContextConfiguration
public class TestThreadPool extends AbstractJUnit4SpringContextTests{
 private static int produceTaskSleepTime = 10;
 private static int produceTaskMaxNumber = 1000;
   
 @Autowired
 private ThreadPoolTaskExecutor threadPoolTaskExecutor;
 public ThreadPoolTaskExecutor getThreadPoolTaskExecutor() {
 return threadPoolTaskExecutor;
 }
 public void setThreadPoolTaskExecutor(
 ThreadPoolTaskExecutor threadPoolTaskExecutor) {
 this.threadPoolTaskExecutor = threadPoolTaskExecutor;
 }
   
 @Test
 public void testThreadPoolExecutor()
 {
 // 构造一个线程池
 final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 600,
 TimeUnit.SECONDS, new ArrayBlockingQueue(3),
 new ThreadPoolExecutor.CallerRunsPolicy());
 for (int i = 1; i <= produceTaskMaxNumber; i++) {
   
 try {
 Thread.sleep(produceTaskSleepTime);
 } catch (InterruptedException e1) {
 e1.printStackTrace();
 }
 new Thread(new StartTaskThread(threadPoolTaskExecutor,i)).start();
 }
 }
}