封装了个线程池+task模式的工具。

现在只支持定义task然后使用线程池（同一个）执行task，对于Task的启停还要研究下，后续再加上吧

 

一、线程池类。静态的线程池类型根据自己需要换成Cache的 还是自定义的（最好自定义一个）

package com.cloudwise.task;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Executor<T> {

	/**
     * 创建线程池线程数量
     */
    private static final int THREAD_NUM = 10;

    /**
     * 创建固定数量的线程池
     */
    private static ExecutorService executor = Executors.newFixedThreadPool(THREAD_NUM);

    /**
     * 获取线程执行完成结果Service
     */
    private CompletionService<T> service = new ExecutorCompletionService<T>(executor);

    /**
     * 提交一个任务
     * 
     * @param task 任务对象
     * @return 单个任务执行结果
     */
    public Future<T> submitTask(Callable<T> task) {
        return service.submit(task);
    }

    /**
     * 获取当前执行完的线程结果
     * 
     * @return 线程池中已执行完的线程结果
     * @throws InterruptedException
     * @throws ExecutionException
     */
    public T takeResult() throws InterruptedException, ExecutionException {
        Future<T> result = service.take();
        return result.get();
    }

    /**
     * 等待所有线程执行完成
     * 
     * @param tasks 任务集合
     * @return 所有任务返回结果集合
     * @throws InterruptedException
     * @throws ExecutionException
     */
    public List<T> invokeAll(List<Callable<T>> tasks) throws InterruptedException, ExecutionException {
        List<T> list = new ArrayList<T>();
        List<Future<T>> results = executor.invokeAll(tasks);
        for (Future<T> result : results) {
            T e = result.get();
            list.add(e);
        }
        return list;
    }
    
    public static void close(){
    	executor.shutdown();
    }
}

二、Task抽象类

package com.cloudwise.task;

import java.util.Map;
import java.util.concurrent.Callable;

public abstract class Task<T> implements Callable<T>{

	/**
     * 传入参数
     */
    protected Map<String, Object> param;

    public Task() {

    }

    public Task(Map<String, Object> param) {
        this.param = param;
    }

    @Override
    public T call() throws Exception {
        T t = invoke(param);
        return t;
    }

    /**
     * 执行任务方法
     * 
     * @param param 所需参数
     * @return 任务返回结果
     */
    protected abstract T invoke(Map<String, Object> param);
}

三、测试的Task类

package com.cloudwise.task;

import java.util.Map;

public class SimpleTask extends Task<String>{

	
	public SimpleTask(Map<String, Object> param){
		 this.param = param;
	}
	@Override
	protected String invoke(Map<String, Object> param) {
		
		if(param != null){
			Object time = param.get("time");
			if(time != null){
				String str = "执行："+time.toString();
				System.out.println(str);
				return str;
			}
		}
		return null;
	}

}

四、试用下

package com.cloudwise.task;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

public class Test {

	
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		Map<String, Object> params = Maps.newHashMap();
		params.put("time", "lala");
		SimpleTask simpleTask = new SimpleTask(params);
		Executor executor = new Executor();
		executor.submitTask(simpleTask);
		List<Task> tasks = Lists.newArrayList();
		tasks.add(simpleTask);
		List invokeAll = executor.invokeAll(tasks);
	}
}