ExecutorThreadHandler 消息处理器

来源：互联网发布：五十知天命六大而耳顺编辑：程序博客网时间：2024/05/22 13:55
应用场景：消息多线程分发到处理器处理。【备忘】
import java.util.ArrayList;import java.util.List;import java.util.concurrent.BlockingQueue;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.atomic.AtomicInteger;import org.apache.log4j.Logger;import com.xx.constant.SystemConfig;/** * 消息处理器 * @author will_awoke * @version 2014-7-16 * @see ExecutorThreadHandler * @since */public final class ExecutorThreadHandler{    /**     * Log     */    private static final Logger log = Logger.getLogger(ExecutorThreadHandler.class);    /**     * singleton instance     */    private static final ExecutorThreadHandler instance = new ExecutorThreadHandler();    /**     * msg counter(atomic ThreadSafe)     */    private final AtomicInteger counter = new AtomicInteger(0);    /**     * 线程池大小 = 当前主机cpu数量 * poolsize     */    private static final Integer threadPoolCapacity = (Runtime.getRuntime().availableProcessors())                                                      * SystemConfig.mqThreadPoolSize;    /**     * 线程池     */    private static final ExecutorService threadPool = Executors.newFixedThreadPool(threadPoolCapacity);    /**     * newly created single-threaded Executor     * 创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。     * 如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。     */    private static final ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();    /**     * singleHandler for singleThreadExecutor     */    private final HandlerThread singleHandler = new HandlerThread();    /**     * 线程池内部对象集合     */    private static final List<HandlerThread> handlerThreadList = new ArrayList<HandlerThread>();    static    {        // 初始化线程池内部对象        for (int i = 0; i < threadPoolCapacity; i++ )        {            handlerThreadList.add(new HandlerThread());        }        // shutdown hook        Runtime.getRuntime().addShutdownHook(new Thread()        {            @Override            public void run()            {                threadPool.shutdown();            }        });    }    /**     * 消息处理线程     */    static class HandlerThread extends Thread    {        // 阻塞队列，初始化容量 FIFO        private BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>(            SystemConfig.mqQueueCapacity);        HandlerThread()        {}        /**         * 将消息添加到阻塞队列中         * @param msg          * @see         */        void put(Object msg)        {            try            {                log.info(getName() + " mqHandlerThread put msg : " + msg.toString());                // 阻塞put                queue.put(msg);            }            catch (InterruptedException e)            {                Thread.currentThread().interrupt();            }        }        @Override        public void run()        {            // 监听是否有新消息到达，有则立即处理，无则阻塞。            while (true)            {                try                {                    // 消息交予后续处理                     Object takeMsg = queue.take();                    log.info(Thread.currentThread().getName() + " mqHandlerThread take msg : "                             + takeMsg.toString());                    //HandlerFactory.handle(takeMsg);//handler工厂处理                }                catch (InterruptedException e)                {                    Thread.currentThread().interrupt();                }            }        }    }    /**     * core handler method (not static)     * @param msg  msg that needs dispatch to the server     * @see     */    public void handler(Object msg)    {        // 以原子方式将当前值加 1，返回更新后的值（即消息计数器+1）        int currentCounterVal = counter.incrementAndGet();        // 消息计数器对线程池容量取余，以保障消息尽可能的平均分配到每个线程进行处理        int listIndex = currentCounterVal % threadPoolCapacity;        HandlerThread run = handlerThreadList.get(listIndex);        log.debug("currentCounterVal " + currentCounterVal + " handlerThreadList index "                  + listIndex);        // 线程池执行当前线程        threadPool.execute(run);        // 将消息put到线程内部阻塞队列中，等待处理即可        run.put(msg);    }    /**     * 特殊的消息放到单线程串行化处理，以保证并发安全。     * @param msg  msg that needs dispatch to the server for singleThread     * @see     */    public void handlerSingleThread(Object msg)    {        // single线程池执行 singleHandler        singleThreadExecutor.execute(singleHandler);                // 将消息put到线程内部阻塞队列中，等待处理即可        singleHandler.put(msg);    }    /**     * singleton     * @return     * @see      */    public static ExecutorThreadHandler getInstance()    {        return instance;    }    /**     * private     */    private ExecutorThreadHandler()    {    }}
0 0