Java Android线程池实践指南及高频问题

public ThreadPoolExecutor(
    int corePoolSize,      // 核心线程数
    int maximumPoolSize,   // 最大线程数
    long keepAliveTime,    // 非核心线程存活时间
    TimeUnit unit,         // 时间单位
    BlockingQueue<Runnable> workQueue,  // 任务队列
    ThreadFactory threadFactory,        // 线程工厂
    RejectedExecutionHandler handler    // 拒绝策略
)

提交任务
   ↓
当前线程数 < corePoolSize？
   ├── 是 → 创建新线程执行任务
   └── 否 → 任务加入 workQueue
              ↓
        队列是否已满？
           ├── 否 → 排队等待
           └── 是 → 当前线程数 < maximumPoolSize？
                        ├── 是 → 创建临时线程执行任务
                        └── 否 → 执行拒绝策略

// 1. 固定线程数
ExecutorService fixed = Executors.newFixedThreadPool(10);
// 等价于：core=max=10, 无界 LinkedBlockingQueue
// ❌ 坑：队列无界，任务堆积可能 OOM

// 2. 单线程
ExecutorService single = Executors.newSingleThreadExecutor();
// 等价于：core=max=1, 无界 LinkedBlockingQueue
// ❌ 坑：同上

// 3. 可缓存线程池
ExecutorService cached = Executors.newCachedThreadPool();
// 等价于：core=0, max=Integer.MAX_VALUE, SynchronousQueue, 60s 回收
// ❌ 坑：允许创建无限线程，可能 OOM

// 4. 定时任务
ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(5);
// 等价于：core=5, max=Integer.MAX_VALUE, DelayedWorkQueue
// ❌ 坑：max 无限制

public class ThreadPoolManager {
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    private static final int MAX_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final long KEEP_ALIVE = 30L;

    private static final ThreadPoolExecutor executor = new ThreadPoolExecutor(
        CORE_POOL_SIZE,
        MAX_POOL_SIZE,
        KEEP_ALIVE,
        TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(128),  // ✅ 有界队列！
        new ThreadFactory() {
            private final AtomicInteger count = new AtomicInteger(1);
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "App-Pool-" + count.getAndIncrement());
            }
        },
        new ThreadPoolExecutor.CallerRunsPolicy()  // ✅ 自我保护
    );

    public static void execute(Runnable task) {
        executor.execute(task);
    }

    public static Future<?> submit(Runnable task) {
        return executor.submit(task);
    }
}

// API 11+ 后 AsyncTask 内部线程池：
private static final int CORE_POOL_SIZE = 5;
private static final int MAXIMUM_POOL_SIZE = 128;
private static final int KEEP_ALIVE = 1;
private static final BlockingQueue<Runnable> sPoolWorkQueue =
    new LinkedBlockingQueue<Runnable>(10);  // 有界队列 10

// Dispatchers.Default —— 对应 JVM 的 ForkJoinPool.commonPool()
// 线程数 = CPU 核心数（至少 2）

// Dispatchers.IO —— 共享 Default 的线程，但最大线程数为 64
// 适合阻塞 IO 操作

// 自定义：
val customDispatcher = Executors.newFixedThreadPool(4).asCoroutineDispatcher()

Future<Integer> future = executor.submit(() -> 42);
Integer result = future.get(); // 阻塞获取结果

executor.shutdown();        // 优雅关闭：不再接受新任务，等待已有任务完成
// executor.shutdownNow(); // 强制关闭：尝试中断正在执行的任务

try {
    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        executor.shutdownNow();  // 超时后强制关闭
    }
} catch (InterruptedException e) {
    executor.shutdownNow();
}

// 常用指标
executor.getPoolSize();         // 当前线程数
executor.getActiveCount();      // 活跃线程数
executor.getQueue().size();     // 队列积压数
executor.getCompletedTaskCount(); // 已完成任务数
executor.getTaskCount();        // 总任务数

// 子线程池执行任务，结果通过 Handler 抛回主线程
Handler mainHandler = new Handler(Looper.getMainLooper());

executor.execute(() -> {
    final Bitmap bitmap = loadBitmap(url);  // 耗时操作
    mainHandler.post(() -> imageView.setImageBitmap(bitmap));  // UI 更新
});

// 并发请求多个接口，等待全部完成后统一处理
CountDownLatch latch = new CountDownLatch(3);
for (String url : urls) {
    executor.execute(() -> {
        try {
            download(url);
        } finally {
            latch.countDown();
        }
    });
}
latch.await();  // 阻塞等待所有任务完成
mergeResults();

线程池
├── 为什么用？ → 复用、控制、管理
├── 核心类 ThreadPoolExecutor
│   ├── 7 大参数
│   ├── 任务提交流程（core → queue → max → reject）
│   └── 4 种拒绝策略
├── 队列类型（SynchronousQueue / LinkedBlockingQueue / ArrayBlockingQueue）
├── Executors 工厂（❌ 不推荐，隐藏 OOM 风险）
├── Android 实践
│   ├── 自定义有界线程池
│   ├── AsyncTask（已废弃，串行/并行）
│   └── Kotlin 协程 Dispatcher
└── 高频考点
    ├── submit vs execute
    ├── 优雅关闭
    ├── 线程数配置
    ├── FutureTask 原理
    └── 线程异常处理