现在只支持定义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);
}
}