Android使用统一的工具类在公用线程池执行后台操作

禁止直接使用 new Thread() 创建线程（线程池除外），而需要使用统一的工具类在公用线程池执行后台操作。

线程池的优点

重用线程池里的线程，避免创建和销毁线程所带来的性能开销
有效控制最大并发数，避免造成线程间抢占系统资源而造成阻塞
提高线程可管理性，可以统一进行分配，调优和监控的能力

Android中的线程池

复用Java中的Executor接口，具体实现类为ThreadPoolExecutor，它有以下几个参数：
corePoolSize

线程池中核心线程数量。（一直存活，即使处于闲置状态）
maximumPoolSize

最大能创建的线程数量。非核心线程，包含核心线程个数。（达到这个值后，后续任务会阻塞）
keepAliveTime

非核心线程最大存活时间。（当设置allowCoreThreadTimeOut=true 同样会做用于核心线程，但通常不会这么做）
unit

keepAliveTime的时间单位。（TimeUnit中的枚举(时间单位)）
workQueue

等待队列。execute 方法提交的Runnable存储在其中。（如果线程池中的线程数量大于等于corePoolSize的时候，把该任务放入等待队列）
threadFactory

线程创建工厂，用来创建线程的。（默认使用Executors.defaultThreadFactory() 来创建线程，线程具有相同的NORM_PRIORITY优先级并且是非守护线程）
handler

线程池的饱和拒绝策略(不常用)。（阻塞队列已且没有空闲的线程，此时继续提交任务，就需要采取一种策略处理该任务，默认会抛出异常）

常用与关键方法

void execute(Runnable run)//提交任务,交由线程池调度

void shutdown()//关闭线程池,等待任务执行完成

void shutdownNow()//关闭线程池，不等待任务执行完成

int getTaskCount()//返回线程池找中所有任务的数量 (已完成的任务+阻塞队列中的任务)

int getCompletedTaskCount()//返回线程池中已执行完成的任务数量 (已完成的任务)

int getPoolSize()//返回线程池中已创建线程数量

int getActiveCount()//返回当前正在运行的线程数量

void terminated()//线程池终止时执行的策略

java 复制代码

ThreadHelper.java  -->
public final class ThreadHelper {
    public static final ThreadHelper INST = new ThreadHelper();

    private ExecutorService executors;

    private ThreadHelper(){
    }

    /**
     * 在线程中执行
     * @param runnable 要执行的runnable
     */
    public void execute(Runnable runnable) {
        ExecutorService executorService = getExecutorService();
        if (executorService != null) {
            executorService.execute(runnable);
        } else {
            new Thread(runnable).start();
        }
    }

    /**
     * 获取缓存线程池
     * @return 缓存线程池服务
     */
    private ExecutorService getExecutorService(){
        if (executors == null) {
            executors = Executors.newCachedThreadPool();
        }

        return executors;
    }
}

java 复制代码

ThreadPoolUtils.java -->
package com.youkagames.gameplatform.support.utils;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolUtils {
    public static volatile ThreadPoolExecutor pool = null;


    private final static int CORE_POOL_SIZE = 10;//核心线程数
    private final static int MAXIMUM_POOL_SIZE = 50;//最大线程数
    private final static long KEEP_ALIVE_TIME = 5;//非核心线程空闲时间
    private final static int MAXIMUM_WORK_QUEUE = 400;//消息队列最大任务数

    private ThreadPoolUtils() {
        pool = new ThreadPoolExecutor(CORE_POOL_SIZE,// 1. 核心线程数
                MAXIMUM_POOL_SIZE,// 2. 最大线程数
                KEEP_ALIVE_TIME, // 3. 非核心线程空闲时间
                TimeUnit.SECONDS, // 4. 时间单位
                new ArrayBlockingQueue<>(MAXIMUM_WORK_QUEUE),// 5. 阻塞队列
                Executors.defaultThreadFactory(),// 6. 创建线程工厂
                new ThreadPoolExecutor.AbortPolicy());// 7. 拒绝策略
        LogUtil.e("xulei", "PushThreadPoolUtils 线程池创建完成");
    }

    public static ThreadPoolExecutor getInstance() {
        //双重if单例
        if (null == pool) {
            synchronized (ThreadPoolUtils.class) {
                if (pool == null) {
                    new ThreadPoolUtils();
                    return pool;
                }
            }
        }
        return pool;
    }

    // 无响应执行
    public static void execute(Runnable runnable) {
        getInstance().execute(runnable);
    }

    // 有响应执行
    public static <T> Future<T> submit(Callable<T> callable) {
        return getInstance().submit(callable);
    }

}

👀关注公众号：Android老皮！！！欢迎大家来找我探讨交流👀