Android-线程池

对于执行大量并行任务, 使用线程池:
1. 可减少创建和销毁线程上的消耗和”切换过度”;
2. 同时避免大量创建线程耗尽内存;

建议通过ThreadPoolExecutor而不是Executors创建线程池; 原因如下
1. FixedThreadPool,SingleThreadPool 可能导致积压大量请求(Integer.MAX_VALUE)
2. CachedThreadPool,ScheduledThreadPool 可能导致创建大量Thread对象(Integer.MAX_VALUE)

构造方法:

public ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit,
    workQueue, ThreadFactory, RejectedExecutionHandler);

参数说明:
    corePoolSize: 核心线程数;
    maximumPoolSize: 最大线程数;
    keepAliveTime, unit: 空闲的非核心线程保活时长;
    workQueue: 任务队列;

注: 线程池中初始线程数为0, 每有新任务到来都会新建线程直到线程数达到 corePoolSize;
当前线程数 >= corePoolSize时,新任务会在workQueue 等待执行, 当队列满时再新建非核心线程;
若当前线程 >= maximumPoolSize且workQueue满, 则拒绝服务RejectedExecutionHandler;

上一份典型代码:

import android.os.Process;
import android.support.annotation.NonNull;
import android.util.Log;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class AppThreadPool {

    private static final String TAG = "AppThreadPool";

    private ThreadPoolExecutor mBackgroundPoolExecutor;

    private static final class AppThreadPoolHolder {
        private static final AppThreadPool sInstance = new AppThreadPool();
    }

    private AppThreadPool() {
        int cpuCount = Runtime.getRuntime().availableProcessors();
        int corePoolSize = Math.max(2, Math.min(cpuCount - 1, 4));
        int maximumPoolSize = cpuCount * 2 + 1;
        int keepAliveTime = 1;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(128);
        mBackgroundPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
                keepAliveTime, unit, workQueue, new ThreadFactory() {
            private int count = 0;

            @Override
            public Thread newThread(@NonNull Runnable r) {
                return new Thread(r, TAG + "-BackgroundThread-" + (++count)) {
                    @Override
                    public void run() {
                        // -20~19 优先级高->低, UI线程 = THREAD_PRIORITY_DEFAULT = 0
                        android.os.Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                        super.run();
                    }
                };
            }
        }, new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                String sJson = "{"
                        + "\"corePoolSize\": " + executor.getCorePoolSize() + ", "
                        + "\"maximumPoolSize\": " + executor.getMaximumPoolSize() + ", "
                        + "\"largestPoolSize\": " + executor.getLargestPoolSize() + ", "
                        + "\"poolSize\": " + executor.getPoolSize() + ", "
                        + "\"activeCount\": " + executor.getActiveCount() + ", "
                        + "\"taskCount\": " + executor.getTaskCount() + ", "
                        + "\"completedTaskCount\": " + executor.getCompletedTaskCount() + " }";
                Log.e(TAG, "rejectedExecution: executor: " + sJson + " , runnable: " + r);
            }
        });
        // 空闲时, 非核心线程保活策略应用在核心线程上
        mBackgroundPoolExecutor.allowCoreThreadTimeOut(true);

    }

    public static AppThreadPool getInstance() {
        return AppThreadPoolHolder.sInstance;
    }

    public Future<?> submit(@NonNull Runnable r) {
        return mBackgroundPoolExecutor.submit(r);
    }

    public <T> Future<T> submit(@NonNull Callable<T> r) {
        return mBackgroundPoolExecutor.submit(r);
    }

以上。

转载请声明来源，谢谢。