java线程池

先直接上代码

线程池调度类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 线程池调度类
 * User: zhaop
 * Date: 15-2-3
 * Time: 下午4:19
 */
public class ThreadScheduler {
    private static final Logger logger = LoggerFactory.getLogger(ThreadScheduler.class);

    private ThreadPoolExecutor producerPool = null;

    private static ThreadScheduler threadScheduler = null;

    private static final int THREAD_POOL_KEEP_ALIVE_TIME = 30;
    private static final int THREAD_POOL_MAX_SIZE = 100000;
    private static final int THREAD_POOL_INIT_SIZE = 100;

    public ThreadScheduler() {
        // 构造一个线程池
        producerPool = new ThreadPoolExecutor(THREAD_POOL_INIT_SIZE,
                THREAD_POOL_MAX_SIZE,
                THREAD_POOL_KEEP_ALIVE_TIME, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(),
                new ThreadPoolExecutor.AbortPolicy());
        // producerPool.allowCoreThreadTimeOut(true);
    }

    public static ThreadScheduler getPool() {
        if (null == threadScheduler || threadScheduler.producerPool.isShutdown())
            synchronized (ThreadScheduler.class) {
                if (null == threadScheduler || threadScheduler.producerPool.isShutdown()) {
                    threadScheduler = new ThreadScheduler();
                }
            }
        return threadScheduler;
    }


    public void exeThread(Runnable tm) {
        // 向线程池派送一个任务。
        try {
            producerPool.execute(tm);
            //logger.info("线程池当前线程数为："+producerPool.getPoolSize());
        } catch (RejectedExecutionException e) {
            logger.error("线程池派送任务发生错误!当前线程数为：" + producerPool.getPoolSize() + "，错误信息为："
                    + e.getMessage(), e);
        }
    }

    public void shutdown() {
        //关闭线程池
        try {
            threadScheduler.producerPool.shutdownNow();
        } catch (RejectedExecutionException e) {
            logger.error("关闭线程池发生错误!错误信息为："
                    + e.getMessage(), e);
        }
    }

    public int getCurPoolSize(){
        return producerPool.getPoolSize();
    }

    public static void setMaximumPoolSize(int maxPoolSize) {
        if(null != threadScheduler){
            threadScheduler.producerPool.setMaximumPoolSize(maxPoolSize);
        }
    }

    public static void setTHREAD_POOL_INIT_SIZE(int thread_pool_init_size) {
        if (null != threadScheduler){
            threadScheduler.producerPool.setCorePoolSize(thread_pool_init_size);
        }
    }


}

 

线程分发器

import cn.ac.ict.xcloud.constants.ProjectConstants;
import cn.ac.ict.xcloud.msgqueue.threadPool.ThreadScheduler;
import cn.ac.ict.xcloud.zookeeperclient.ZookeeperClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * User: zhaop
 * Date: 15-2-3
 * Time: 下午8:46
 */
public class HandlerDispatch {
    private static final Logger log = LoggerFactory.getLogger(HandlerDispatch.class);
    private static HandlerDispatch handlerDispatch = null;
    private static Object lock = new Object();
    private boolean waiting = false; //线程是否被挂起

    private int totalThread = ZookeeperClient.getInstance().getIntegerProperty(ProjectConstants.XCLOUD_MQ_PROJECT, "TOTAL_THREAD", 50); // 总线程数
    private int curThread = 0; //当前线程数


    public static HandlerDispatch getHandlerDispatch() {
        if (null == handlerDispatch)
            synchronized (HandlerDispatch.class) {
                if (null == handlerDispatch) {
                    handlerDispatch = new HandlerDispatch();
                }
            }
        return handlerDispatch;
    }


    public void addWorker(WorkerThread abstractHanler) {
        if (curThread < totalThread) {
            synchronized (lock) {
                ThreadScheduler.getPool().exeThread(abstractHanler);
                curThread++;
                log.info("正在运行线程数[" + curThread + "/" + totalThread + "]");
            }
        } else {
            try {
                synchronized (this) {
                    log.info("运行线程数达到最大值，接收消息线程被挂起");
                    if (!waiting){
                        waiting = true;
                        this.wait(); //挂起
                    }
                }
            } catch (InterruptedException e) {
                log.error(e.getMessage(), e);
            }
        }
    }

    public void finishWorker(){
        synchronized (lock) {
            curThread--;
            log.info("正在运行线程数[" + curThread + "/" + totalThread + "]");
            if (curThread < totalThread && waiting){
                log.info("唤醒接收消息线程");
                synchronized(this){
                    waiting = false;
                    this.notifyAll();
                }
            }
        }
    }


    public int getCurThread() {
        return curThread;
    }

    public void setCurThread(int curThread) {
        this.curThread = curThread;
    }

    public int getTotalThread() {
        return totalThread;
    }

    public void setTotalThread(int totalThread) {
        this.totalThread = totalThread;
    }


}

线程类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * Created with IntelliJ IDEA.
 * User: zhaop
 * Date: 15-2-3
 * Time: 下午4:36
 */

@Component
public class WorkerThread implements Runnable{
    private static final Logger logger = LoggerFactory.getLogger(WorkerThread.class);

    private IHandler handler;
    private String message;

    public WorkerThread(){
    }

    public WorkerThread(IHandler handler, String message){
        this.handler = handler;
        this.message = message;
    };

    public void callBack(){
        logger.info("线程工作结束，回调...");
        HandlerDispatch.getHandlerDispatch().finishWorker();
    }

    @Override
    public void run() {
        handler.handleMessage(message);
        callBack();
    }
}

 

调用方式

 workerThread = new WorkerThread(userMsgHandler,userMsg);
 HandlerDispatch.getHandlerDispatch().addWorker(workerThread);