學習log1_Android線程池管理工具類

import android.os.Handler;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
 
 *  描述：    線程池管理類
 */
public class ExecutorManager {

    private static volatile ExecutorManager mInstance = null;

    private Handler mHandler = new Handler();

    //核心線程數
    private static final int THREAD_CORE_SIZE = 8;

    //線程對象
    private ExecutorService mCoreThread;
    private ExecutorService mSingleThread;
    private ExecutorService mCacheThread;

    private ExecutorManager() {
        initExecutor();
    }

    public static ExecutorManager getInstance() {
        if (mInstance == null) {
            synchronized (ExecutorManager.class) {
                if (mInstance == null) {
                    mInstance = new ExecutorManager();
                }
            }
        }
        return mInstance;
    }

    private void initExecutor() {
        //可重用的核心線程
        mCoreThread = Executors.newFixedThreadPool(THREAD_CORE_SIZE);
        //隊列線程
        mSingleThread = Executors.newSingleThreadExecutor();
        //非核心線程
        mCacheThread = Executors.newCachedThreadPool();
    }

    /**
     * 執行核心線程
     * 核心線程不會銷燬，執行完任務後會等待新的任務
     *
     * @param command 任務
     */
    public void executeCore(Runnable command) {
        mCoreThread.execute(command);
    }

    /**
     * 執行核心線程
     * 核心線程不會銷燬，執行完任務後會等待新的任務
     *
     * @param listener 回調
     */
    public void executeCore(OnTreadPoolListener listener) {
        mCoreThread.execute(() -> {
            listener.onThread();
            mHandler.post(listener::onUIThread);
        });
    }

    /**
     * 執行核心線程
     * 核心線程不會銷燬，執行完任務後會等待新的任務
     *
     * @param listener 回調
     */
    public <T> void executeCore(OnTreadEventPoolListener<T> listener) {
        mCoreThread.execute(() -> {
            T t = listener.onThread();
            mHandler.post(() -> listener.onUIThread(t));
        });
    }

    /**
     * 隊列線程
     * 隊列線程只有一個核心任務，每次新增任務都會排隊執行
     *
     *
     * @param command 任務
     */
    public void executeSingle(Runnable command) {
        mSingleThread.execute(command);
    }

    /**
     * 隊列線程
     * 隊列線程只有一個核心任務，每次新增任務都會排隊執行
     *
     * @param listener 回調
     */
    public void executeSingle(OnTreadPoolListener listener) {
        mSingleThread.execute(() -> {
            listener.onThread();
            mHandler.post(listener::onUIThread);
        });
    }

    /**
     * 隊列線程
     * 隊列線程只有一個核心任務，每次新增任務都會排隊執行
     *
     * @param listener 回調
     */
    public <T> void executeSingle(OnTreadEventPoolListener<T> listener) {
        mSingleThread.execute(() -> {
            T t = listener.onThread();
            mHandler.post(() -> listener.onUIThread(t));
        });
    }

    /**
     * 非核心線程
     * 非核心線程在執行完任務後有60s等待時間，超時後將銷燬線程
     *
     * @param command 任務
     */
    public void executeCache(Runnable command) {
        mCacheThread.execute(command);
    }

    /**
     * 非核心線程
     * 非核心線程在執行完任務後有60s等待時間，超時後將銷燬線程
     *
     * @param listener 任務
     */
    public void executeCache(OnTreadPoolListener listener) {
        mCacheThread.execute(() -> {
            listener.onThread();
            mHandler.post(listener::onUIThread);
        });
    }

    /**
     * 非核心線程
     * 非核心線程在執行完任務後有60s等待時間，超時後將銷燬線程
     *
     * @param listener 任務
     */
    public <T> void executeCache(OnTreadEventPoolListener<T> listener) {
        mCacheThread.execute(() -> {
            T t = listener.onThread();
            mHandler.post(() -> listener.onUIThread(t));
        });
    }

    public interface OnTreadPoolListener {
        //子線程
        void onThread();

        //UI線程
        void onUIThread();
    }

    //具備傳參的接口
    public interface OnTreadEventPoolListener<T> {
        //子線程
        T onThread();

        //UI線程
        void onUIThread(T t);
    }
}