线程池

单例模式

public class ThreadPoolManager {
    private volatile static ThreadPoolManager INSTANCE;
    private ExecutorService mThreadPool;

    private ThreadPoolManager() {
        mThreadPool = new ThreadPoolExecutor(getMAX_POOL_SIZE(),
                getMAX_POOL_SIZE(), KEEP_ALIVE_TIME,
                TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(),
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread thread = new Thread(r);
                        thread.setName("FaceThread");
                        return thread;
                    }
                });
    }

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

    public void execute(Runnable runnable) {
        mThreadPool.execute(runnable);
    }

    public void shutdownNow() {
        mThreadPool.shutdownNow();
        INSTANCE = null;
    }
}

 

常量：

val MAX_POOL_SIZE = CORE_POOL_SIZE shl 1
const val KEEP_ALIVE_TIME = 100