Android中线程池使用

ThreadPoolManager

java 复制代码

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public enum ThreadPoolManager {
    INSTANCE;
    // 固定大小线程池
    private final ExecutorService fixedThreadPool;
    // 单线程线程池
    private final ExecutorService singleThreadPool;
    // 缓存线程池
    private final ExecutorService cachedThreadPool;
    // 定时任务线程池
    private final ScheduledExecutorService scheduledThreadPool;

    ThreadPoolManager() {
        // 创建固定大小线程池，线程数量为 CPU 核心数的两倍
        int coreCount = Runtime.getRuntime().availableProcessors();
        fixedThreadPool = Executors.newFixedThreadPool(coreCount * 2);

        // 创建单线程线程池
        singleThreadPool = Executors.newSingleThreadExecutor();

        // 创建缓存线程池
        cachedThreadPool = Executors.newCachedThreadPool();

        // 创建定时任务线程池，线程数量为 CPU 核心数的两倍
        scheduledThreadPool = Executors.newScheduledThreadPool(coreCount * 2);
    }

    /**
     * 在固定大小线程池中执行任务
     * @param task 要执行的任务
     */
    public void executeOnFixedThreadPool(Runnable task) {
        if (task != null) {
            fixedThreadPool.execute(task);
        }
    }

    public <T> Future<T> submit(Callable<T> callable) {
        if (callable != null) {
            return fixedThreadPool.submit(callable);
        }
        return null;
    }
    /**
     * 在单线程线程池中执行任务
     * @param task 要执行的任务
     */
    public void executeOnSingleThreadPool(Runnable task) {
        if (task != null) {
            singleThreadPool.execute(task);
        }
    }

    /**
     * 在缓存线程池中执行任务
     * @param task 要执行的任务
     */
    public void executeOnCachedThreadPool(Runnable task) {
        if (task != null) {
            cachedThreadPool.execute(task);
        }
    }

    /**
     * 在定时任务线程池中延迟执行任务
     * @param task 要执行的任务
     * @param delay 延迟时间
     * @param unit 时间单位
     */
    public void scheduleOnScheduledThreadPool(Runnable task, long delay, TimeUnit unit) {
        if (task != null) {
            scheduledThreadPool.schedule(task, delay, unit);
        }
    }

    /**
     * 在定时任务线程池中按固定速率执行任务
     * @param task 要执行的任务
     * @param initialDelay 初始延迟时间
     * @param period 执行周期
     * @param unit 时间单位
     */
    public void scheduleAtFixedRateOnScheduledThreadPool(Runnable task, long initialDelay, long period, TimeUnit unit) {
        if (task != null) {
            scheduledThreadPool.scheduleWithFixedDelay(task, initialDelay, period, unit);
        }
    }

    /**
     * 关闭所有线程池
     */
    public void shutdownAll() {
        if (!fixedThreadPool.isShutdown()) {
            fixedThreadPool.shutdown();
        }
        if (!singleThreadPool.isShutdown()) {
            singleThreadPool.shutdown();
        }
        if (!cachedThreadPool.isShutdown()) {
            cachedThreadPool.shutdown();
        }
        if (!scheduledThreadPool.isShutdown()) {
            scheduledThreadPool.shutdown();
        }
    }
}

ThreadUtils

java 复制代码

import android.os.Handler;
import android.os.Looper;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;


public enum ThreadUtils {
    INSTANCE;
    private final Handler mainHandler = new Handler(Looper.getMainLooper());

    /**
     * 在异步线程中执行任务
     * @param runnable 要执行的任务
     */
    public void executeAsync(Runnable runnable) {
        if (runnable != null) {
            ThreadPoolManager.INSTANCE.executeOnFixedThreadPool(runnable);
        }
    }

    /**
     * 在主线程中执行任务
     * @param runnable 要执行的任务
     */
    public void runOnMainThread(Runnable runnable) {
        if (runnable != null) {
            if (Looper.myLooper() == Looper.getMainLooper()) {
                // 如果当前已经在主线程，直接执行
                runnable.run();
            } else {
                // 否则，通过 Handler 切换到主线程执行
                mainHandler.post(runnable);
            }
        }
    }

    /**
     * 异步执行 Callable 任务并返回 Future
     * @param callable 要执行的任务
     * @param <T> 任务返回值的类型
     * @return 用于获取任务结果的 Future 对象
     */
    public <T> Future<T> submitAsync(Callable<T> callable) {
        if (callable != null) {
            return ThreadPoolManager.INSTANCE.submit(callable);
        }
        return null;
    }
}

使用：

Lambda 表达式()->{}说明：

需 Java 8+（Android 需 minSdk ≥ 24，或启用 desugar 支持低版本）。

java 复制代码

//同步主线程
ThreadUtils.INSTANCE.runOnMainThread(()->{});
//异步子线程
ThreadUtils.INSTANCE.executeAsync(()->{});

()->{}比匿名内部类要好
	new Thread(){
        @Override
        public void run() {
            super.run();
                
        }
    }.start();