线程池使用样例

1. TaskProcessor.java

package y2013.thread.useDemo;


import java.util.HashMap;
import java.util.Map;


/**
 *  处理任务抽象类
 * 〈功能详细描述〉
 * @author liudong
 * @version Dec 23, 2010
 * @see TaskProcessor
 * @since
 */
public abstract class TaskProcessor
{

    private Map<String, Object> params = new HashMap<String, Object>();

    private String primaryKey;

    /**构造函数
     * @param primaryKey 主键
     * @param paramMap 参数
     */
    public TaskProcessor(String primaryKey, Map<String, Object> paramMap)
    {
        this.primaryKey = primaryKey;
        this.params.putAll(paramMap);
    }

    /**
     * Description: <br>
     * 1、…<br>
     * 2、…<br>
     * Implement: <br>
     * 1、…<br>
     * 2、…<br>
     *  
     * @see 
     */
    public abstract void processor();

    /**
     * Description: <br>
     * 1、…<br>
     * 2、…<br>
     * Implement: <br>
     * 1、…<br>
     * 2、…<br>
     * 
     * @return  String
     * @see 
     */
    public String getPrimaryKey()
    {
        return primaryKey;
    }

    /**
     * Description: <br>
     * 1、…<br>
     * 2、…<br>
     * Implement: <br>
     * 1、…<br>
     * 2、…<br>
     * 
     * @return Map<String, Object>
     * @see 
     */
    public Map<String, Object> getParams()
    {
        return params;
    }

}

2. ThreadPoolManager.java

package y2013.thread.useDemo;


import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


/**
 * 线程池管理类
 * @see ThreadPoolManager
 * @since
 */
public class ThreadPoolManager
{

    /**
     * 单例
     */
    private static ThreadPoolManager tpm = new ThreadPoolManager();

    /**
     * ConcurrentHashMap 初始容量
     */
    private static final int INITIALCAPACTITY = 16;

    /**
     * ConcurrentHashMap 加载因子阈值
     */
    private static final float LOADFACTOR = 0.75f;

    /**
     * 异常任务队列
     */
    @SuppressWarnings("unchecked")
    private Queue<Runnable> backQueue = new ConcurrentLinkedQueue<Runnable>();

    /**
     * 通过主键判断该任务是否处于线程池中
     */
    private Queue<String> executeQueue = new ConcurrentLinkedQueue<String>();

    /**
     * 记载异常任务重复执行次数,支持线程池所有线程共同访问
     */
    private ConcurrentMap<Integer, Integer> countMap =
        new ConcurrentHashMap<Integer, Integer>(INITIALCAPACTITY, LOADFACTOR, 10000);

    /**
     * 访问异常任务队列的调度线程
     */
    private final Runnable accessBufferThread = new Runnable()
    {

        public void run()
        {
            //设置线程名称
            Thread.currentThread().setName("taskHandler");
            if (hasMoreAcquire())
            {
                Runnable runnable = getBackRunnable();

                if (!addTaskToPool(false, runnable))
                {
                    processFailureTask(runnable);
                }
            }
        }

    };

    /**
     * 线程池对象
     */
    @SuppressWarnings("unchecked")
    private final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 5, 1, TimeUnit.SECONDS,

    new ArrayBlockingQueue(10000), new ThreadPoolExecutor.CallerRunsPolicy());

    /**
     * 处理失败任务的线程池
     */
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    /**
     * 处理失败任务
     */
    @SuppressWarnings("unchecked")
    private final ScheduledFuture taskHandler =
        scheduler.scheduleAtFixedRate(accessBufferThread, 0, 1, TimeUnit.SECONDS);

    /**
     * 空的构造函数
     */
    private ThreadPoolManager()
    {
    }

    /**
     * 返回线程池管理对象（单例）
     * @return ThreadPoolManager
     * @see 
     */
    public static ThreadPoolManager newInstance()
    {
        return tpm;

    }

    /**
     * 返回是否有任務在執行
     * @return boolean
     * @see
     */
    public boolean isDone()
    {
        return taskHandler.isDone();
    }

    /**获取异常队列中的线程
     * @return Runnable
     * @see 
     */
    public Runnable getBackRunnable()
    {
        return backQueue.poll();
    }

    /**判断异常任务队列是否为空
     * @return boolean
     */
    public boolean hasMoreAcquire()
    {
        return !backQueue.isEmpty();
    }

    /**把主键放入缓存
     * @param primaryKey 主键
     * @see 
     */
    public void putPrimaryKey(String primaryKey)
    {
        executeQueue.add(primaryKey);
    }

    /**判断主键是否在缓存中存在
     * @param primaryKey primaryKey
     * @return  boolean
     * @see 
     */
    public boolean isExistByPrimaryKey(String primaryKey)
    {
        return executeQueue.contains(primaryKey);
    }

    /**从缓存中移除主键
     * @param primaryKey  主键
     * @see 
     */
    public void removePrimaryKey(String primaryKey)
    {
        executeQueue.remove(primaryKey);
    }

    /**把失败的任务放入异常队列
     * @param r 失败任务
     */
    public void putBackQueue(Runnable r)
    {
        backQueue.add(r);
    }

    /**处理失败的任务
    * @param r 任务线程
    */
    public void processFailureTask(Runnable r)
    {

        backQueue.add(r);
        synchronized (r)
        {
            Integer value = countMap.get(r.hashCode());
            if (value == null)
            {
                value = Integer.valueOf(0);
            }
            value = value + 1;
            countMap.put(r.hashCode(), value);

            //最大执行次数超过3次，则取消此线程
            if (value > 3)
            {

                backQueue.remove(r);
                countMap.remove(r.hashCode());
            }
        }
    }

    /**处理成功的任务
     * @param r 任务线程
     */
    public void processSuccessTask(Runnable r)
    {
        countMap.remove(r.hashCode());
    }

    /**把新的任务加入线程池中
     * @param isLimit 是否判断队列长度
     * @param runnable 任务线程
     * @return boolean
     * @see 
     */
    public boolean addTaskToPool(boolean isLimit, Runnable runnable)
    {
        //是否需要判断线程池队列的已有长度
        if (isLimit)
        {
            BlockingQueue<Runnable> blockingQueue = threadPool.getQueue();

            //线程数达到10000则不在增加新的线程，返回操作失败
            if (blockingQueue.size() >= 10000)
            {
                return false;
            }
        }
        
        //最终，加入到线程池中处理
        threadPool.execute(runnable);
        return true;
    }
}

3. ThreadPoolMainTask.java

package y2013.thread.useDemo;


/**
 *  处理任务线程类
 * @see ThreadPoolMainTask
 * @since
 */
public class ThreadPoolMainTask
    implements Runnable
{

    /**
     * 任务对象
     */
    private TaskProcessor taskProcessor;

    /**
     * 主键，相同主键的任务不能同时在线程池中执行
     */
    private String primaryKey;

    /**
     * 线程池管理对象（单例）
     */
    private ThreadPoolManager manager = ThreadPoolManager.newInstance();

    /**
     * 构造函数
     * @param taskProcessor taskProcessor
     */
    public ThreadPoolMainTask(TaskProcessor taskProcessor)
    {
        this.taskProcessor = taskProcessor;
        this.primaryKey = taskProcessor.getPrimaryKey();
    }

    /** 
     * 处理任务
     */
    public void run()
    {
        try
        {
            if (!manager.isExistByPrimaryKey(primaryKey))
            {
                //设置线程名称
                Thread.currentThread().setName(primaryKey);
                //执行之前把表的主键放入map
                manager.putPrimaryKey(primaryKey);
                //处理业务逻辑
                taskProcessor.processor();
                //执行完毕把表的主键移除Map
                manager.removePrimaryKey(primaryKey);
                //处理成功的任务
                manager.processSuccessTask(this);
            }
            else
            {
                //处理失败的任务
                manager.putBackQueue(this);
            }
            //设置线程名称
            Thread.currentThread().setName(
                "ThreadPool_Worker-" + String.valueOf(Thread.currentThread().getId()));

        }
        catch (Throwable e)
        {
            //移除主键
            manager.removePrimaryKey(primaryKey);
            //处理失败的任务（限制失败次数不能超过三次）
            manager.processFailureTask(this);
        }

    }

}