线程池单例使用

Java提供的原生线程池技术处理原理很清晰，故只要使用自己的原生线程池技术一般都能满足项目的需求。java提供了很好的线程池实现，比我们自己的实现要更加健壮以及高效，同时功能也更加强大，不建议自己编写。另外有同学可能用过spring的线程池，那么spring线程池和jdk原生线程池有啥区别吗？我们查看源码和官方api可以知道SpringFrameWork 的 ThreadPoolTaskExecutor 是辅助 JDK 的 ThreadPoolExecutor 的工具类，它将属性通过 JavaBeans 的命名规则提供出来，方便进行配置。也就是说spring的包装了一下jdk，其实底层都是jdk的线程池。如果项目中有spring框架，建议使用spring的线程池（毕竟和环境一起，线程池的生命周期可以让spring容器来管理，当然啦，也可以使用原生的jdk线程池），如果没有其他要求，建议使用原生jdk线程池。

阿里巴巴的编程规范建议也是有异曲同工之妙的说法：

【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。
说明：使用线程池的好处是减少在创建和销毁线程上所花的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

1、原生jdk线程池单例使用

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

/**
 * 线程池管理(线程统一调度管理)
 */
public final class ThreadPoolManager {

    private static ThreadPoolManager sThreadPoolManager = new ThreadPoolManager();

    // 线程池维护线程的最少数量
    private static final int SIZE_CORE_POOL = 15;

    // 线程池维护线程的最大数量
    private static final int SIZE_MAX_POOL = 15;

    /*
     * 线程池单例创建方法
     */
    public static ThreadPoolManager newInstance() {
        return sThreadPoolManager;
    }

    /**************************************************************************************************************
     * 常见的几种线程技术
     ************************************************************************************************************** 
     * Java通过Executors提供四种线程池，分别为：
     * newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
     * newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
     * newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。 newSingleThreadExecutor
     * 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
     *
     * 1、public static ExecutorService newFixedThreadPool(int nThreads) { 
     * return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }
     * 
     * 2、 public static ExecutorService newSingleThreadExecutor() { 
     * return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); } 
     * 
     * 3、public static ExecutorService newCachedThreadPool() { 
     * return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); }
     ****************************************************************************************************************/

    /**
     * 线程池
     * @param corePoolSize - 池中所保存的线程数，包括空闲线程。
     * @param maximumPoolSize - 池中允许的最大线程数。
     * @param keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
     * @param unit - keepAliveTime 参数的时间单位。
     * @param workQueue - 执行前用于保持任务的队列。此队列仅由保持 execute 方法提交的 Runnable 任务。
     * @param handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。
     */
    // 实质就是newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
    private final ThreadPoolExecutor mThreadPool = new ThreadPoolExecutor(SIZE_CORE_POOL, SIZE_MAX_POOL, 0L,
            TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
    
    /*
     * 将构造方法访问修饰符设为私有，禁止任意实例化。
     */
    private ThreadPoolManager() {
    }

    /*
     * 将线程池初始化，核心线程数量
     */
    public void perpare() {
        if (mThreadPool.isShutdown() && !mThreadPool.prestartCoreThread()) {
            @SuppressWarnings("unused")
            int startThread = mThreadPool.prestartAllCoreThreads();
        }
    }

    /*
     * 向线程池中添加任务方法
     */
    public void addExecuteTask(Runnable task) {
        if (task != null) {
            mThreadPool.execute(task);
        }
    }

    /*
     * 判断是否是最后一个任务
     */
    protected boolean isTaskEnd() {
        if (mThreadPool.getActiveCount() == 0) {
            return true;
        } else {
            return false;
        }
    }
    
    /*
     * 获取缓存大小
     */
    public int getQueue(){
        return mThreadPool.getQueue().size();
    }
    
    /*
     * 获取线程池中的线程数目
     */
    public int getPoolSize(){
        return mThreadPool.getPoolSize();
    }
    
    /*
     * 获取已完成的任务数
     */
    public long getCompletedTaskCount(){
        return mThreadPool.getCompletedTaskCount();
    }
    
    /*
     * 关闭线程池，不在接受新的任务，会把已接受的任务执行玩
     */
    public void shutdown() {
        mThreadPool.shutdown();
    }
}

调用demo

 

public class TestThreadPool {

    /**
     * @Name: main
     * @Description: TODO(这里用一句话描述这个类的作用)
     * @Author: tjf
     * @Version: V1.00
     * @CreateDate: 2016年10月18日上午11:44:35
     * @param args
     * @Return: void 返回类型
     */
    public static void main(String[] args) {

        ThreadPoolManager threadPoolManager = ThreadPoolManager.newInstance();
        for (int i = 0; i < 100; i++) {
            threadPoolManager.addExecuteTask(new MyTask(i));
            System.out.println("线程池中线程数目：" + threadPoolManager.getPoolSize() + "，队列中等待执行的任务数目："
                    + threadPoolManager.getQueue() + "，已执行玩别的任务数目：" + threadPoolManager.getCompletedTaskCount());
        }
        threadPoolManager.shutdown();
    }

}

class MyTask implements Runnable {
    private int taskNum;

    public MyTask(int taskNum) {
        this.taskNum = taskNum;
        ;
    }

    @SuppressWarnings("static-access")
    public void run() {
        System.out.println("正在执行task " + taskNum);
        try {
            Thread.currentThread().sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("task " + taskNum + "执行完毕");
    }

    public int getTaskNum() {
        return taskNum;
    }

    public void setTaskNum(int taskNum) {
        this.taskNum = taskNum;
    }

可以应用到全局线程池