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 原理
    └── 线程异常处理