線程池單例使用

Java提供的原生線程池技術處理原理很清晰，故只要使用本身的原生線程池技術通常都能知足項目的需求。java提供了很好的線程池實現，比咱們本身的實現要更加健壯以及高效，同時功能也更增強大，不建議本身編寫。另外有同窗可能用過spring的線程池，那麼spring線程池和jdk原生線程池有啥區別嗎？咱們查看源碼和官方api能夠知道SpringFrameWork 的 ThreadPoolTaskExecutor 是輔助 JDK 的 ThreadPoolExecutor 的工具類，它將屬性經過 JavaBeans 的命名規則提供出來，方便進行配置。也就是說spring的包裝了一下jdk，其實底層都是jdk的線程池。若是項目中有spring框架，建議使用spring的線程池（畢竟和環境一塊兒，線程池的生命週期可讓spring容器來管理，固然啦，也可使用原生的jdk線程池），若是沒有其餘要求，建議使用原生jdk線程池。

阿里巴巴的編程規範建議也是有殊途同歸之妙的說法：

【強制】線程資源必須經過線程池提供，不容許在應用中自行顯式建立線程。
說明：使用線程池的好處是減小在建立和銷燬線程上所花的時間以及系統資源的開銷，解決資源不足的問題。若是不使用線程池，有可能形成系統建立大量同類線程而致使消耗完內存或者「過分切換」的問題。

一、原生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, 優先級)執行。
     *
     * 一、public static ExecutorService newFixedThreadPool(int nThreads) { 
     * return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }
     * 
     * 二、 public static ExecutorService newSingleThreadExecutor() { 
     * return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); } 
     * 
     * 三、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;
    }

能夠應用到全局線程池