封裝了個線程池+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);
	}
}