线程池 ThreadPoolExcutor

《阿里巴巴java开发手册》中指出线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程；而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式等创建线程池，使用ThreadPoolExecutor有助于大家明确线程池的运行规则，规避资源耗尽的风险。

线程池，主线程handler，异步线程handler封装类。

public class TaskExecutor {
    /**
     * 同时处理两个任务
     */
    private static final int POOL = 2;
    private final String EXECUTOR_NAME = "executor_%d";
    /**
     * 主线程Handler
     */
    private volatile Handler mainHandler;
    /**
     * 异步线程Handler
     */
    private volatile Handler asyncHandler;
    /**
     * 异步线程
     */
    private HandlerThread mHandlerThread;
    private ExecutorService mExecutorService;
    private final Object mLock = new Object();

    public TaskExecutor() {
        mExecutorService = new ThreadPoolExecutor(POOL, POOL,
                0, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(),
                new ThreadFactory() {
                    private final AtomicInteger mThreadId = new AtomicInteger(0);

                    @Override
                    public Thread newThread(Runnable r) {
                        Thread thread = new Thread(r);
                        thread.setName(String.format(Locale.getDefault(), EXECUTOR_NAME, mThreadId.getAndIncrement()));
                        return thread;
                    }
                });
        mHandlerThread = new HandlerThread("handler_thread", Process.THREAD_PRIORITY_BACKGROUND);
        mHandlerThread.start();
    }
public static TaskExecutor getInstance() {
        return SingleUtils.get(TaskExecutor.class);
    }

    /**
     * 检查主线程Handler初始化
     */
    private void checkHandlerIsNull() {
        if (mainHandler == null) {
            synchronized (mLock) {
                if (mainHandler == null) {
                    mainHandler = new Handler(Looper.getMainLooper());
                }
            }
        }
    }

    public Handler createAsyncHandler() {
        return createAsyncHandler(null);
    }

    public Handler createAsyncHandler(Handler.Callback callback) {
        synchronized (mLock) {
            return new Handler(mHandlerThread.getLooper(), callback);
        }
    }

    /**
     * 获取异步asyncHandler
     *
     * @return
     */
    public Handler getAsyncHandler() {
        if (asyncHandler == null) {
            synchronized (mLock) {
                if (asyncHandler == null) {
                    asyncHandler = createAsyncHandler();
                }
            }
        }
        return asyncHandler;
    }

    /**
     * 异步执行
     *
     * @param runnable
     */
    public void excuteOnIO(@NonNull Runnable runnable) {
        mExecutorService.execute(runnable);
    }

    /**
     * 主线程执行
     *
     * @param runnable
     */
    public void postToMainThread(@NonNull Runnable runnable) {
        checkHandlerIsNull();
        mainHandler.post(runnable);
    }

    /**
     * 主线程延迟执行
     *
     * @param runnable
     * @param delayMillis
     */
    public void postToMainThread(@NonNull Runnable runnable, long delayMillis) {
        checkHandlerIsNull();
        mainHandler.postDelayed(runnable, delayMillis);
    }

    /**
     * 是否主线程
     *
     * @return
     */
    public boolean isMainThread() {
        return Looper.getMainLooper().getThread() == Thread.currentThread();
    }

    public void release() {
        if (!mExecutorService.isShutdown()) {
            mExecutorService.shutdown();
        }
        if (mainHandler != null) {
            mainHandler.removeCallbacksAndMessages(null);
        }
        if (asyncHandler != null) {
            asyncHandler.removeCallbacksAndMessages(null);
        }
    }
}

可用线程池执行异步任务executeOnIo，比如相关api、第三方sdk的初始化，例：

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

    private MServerImpl() {
        TaskExecutor.getInstance().excuteOnIO(() -> AdaptApiManager.getInstance().xx());
    }