簡單線程池創建

import android.os.Handler;
import android.os.Looper;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created by Lidev on 2020/2/28.
 */

public class ThreadPoolManager <T> {

    /**
     * 根據cpu的數量動態的配置核心線程數和最大線程數
     */
    private static final int CPU_COUNT         = Runtime.getRuntime().availableProcessors();
    /**
     * 核心線程數 = CPU核心數 + 1
     */
    private static final int CORE_POOL_SIZE    = CPU_COUNT + 1;
    /**
     * 線程池最大線程數 = CPU核心數 * 2 + 1
     */
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    /**
     * 非核心線程閒置時超時1s
     */
    private static final int KEEP_ALIVE        = 1;
    /**
     *  線程池的對象
     */
    private ThreadPoolExecutor executor;

    /**
     * 要確保該類只有一個實例對象，避免產生過多對象消費資源，所以採用單例模式
     */
    private ThreadPoolManager() {
    }

    private static ThreadPoolManager sInstance;

    public synchronized static ThreadPoolManager getsInstance() {
        if (sInstance == null) {
            sInstance = new ThreadPoolManager();
        }
        return sInstance;
    }

    /**
     * 開啓一個無返回結果的線程
     * @param r
     */
    public void execute(Runnable r) {
        if (executor == null) {
            /**
             * corePoolSize:核心線程數
             * maximumPoolSize：線程池所容納最大線程數(workQueue隊列滿了之後纔開啓)
             * keepAliveTime：非核心線程閒置時間超時時長
             * unit：keepAliveTime的單位
             * workQueue：等待隊列，存儲還未執行的任務
             * threadFactory：線程創建的工廠
             * handler：異常處理機制
             *
             */
            executor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE,
                    KEEP_ALIVE, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(20),
                    Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        }
        // 把一個任務丟到了線程池中
        executor.execute(r);
    }

    /**
     * 開啓一個有返回結果的線程
     * @param r
     * @return
     */
    public Future<T> submit(Callable<T> r) {
        if (executor == null) {
            /**
             * corePoolSize:核心線程數
             * maximumPoolSize：線程池所容納最大線程數(workQueue隊列滿了之後纔開啓)
             * keepAliveTime：非核心線程閒置時間超時時長
             * unit：keepAliveTime的單位
             * workQueue：等待隊列，存儲還未執行的任務
             * threadFactory：線程創建的工廠
             * handler：異常處理機制
             *
             */
            executor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE,
                    KEEP_ALIVE, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(20),
                    Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        }
        // 把一個任務丟到了線程池中
        return executor.submit(r);
    }

    /**
     * 把任務移除等待隊列
     * @param r
     */
    public void cancel(Runnable r) {
        if (r != null) {
            executor.getQueue().remove(r);
        }
    }


    //新增**************************************************
    private static Handler sMainHandler = new Handler(Looper.getMainLooper());
    /**
     * UI線程執行
     * @param runnable
     */
    public static void runOnUiThread(Runnable runnable) {
        sMainHandler.post(runnable);
    }



}