Android ThreadPoolExecutor 学会管理你的线程池

初入Android 时对于线程管理是一无所知。觉得只要可以实现需求就算是完成项目了。但在接触久了之后才发现自己需要学的、做的还有那么那么多。

new Thread(new Runnable() {
@Override
public void run() {
//todo
}
}).start();

原以为开子线程进行耗时操作这样就可以了。但事实却是内存泄漏。。。直接使用 new 声明的子线程也可称呼为野线程，又是在原以为其执行完 run（）方法会被 gc 回收。其实呢：线程的创建和销毁都需要时间，当有大量的线程创建和销毁时，那么这些时间的消耗则比较明显，将导致性能上的缺失。大量的线程的创建和销毁很容易导致 gc 频繁的执行，从而发生内存抖动现象，而发生了内存抖动，对于移动端来说，最大的影响就是造成界卡帧。

在多方面的原因下，使用线程池对项目中的线程进行管理会让你的项目性能更加优化。下面是一个简单的线程池使用：

1、创建枚举值来确定线程的优先级

/**
* 优先级枚举值
* @author 49829
* @date 2017/12/5
*/

public enum Priority {
HIGH,NORMAL,LOW
}
2、创建一个 Runnable 来执行需要完成的任务
/**
* 优先级 任务
* @author 49829
* @date 2017/12/5
*/

public class PrioriRunnable implements Runnable {
public final Priority priority;
private final Runnable runnable;
long SEQ;

/**
* 构造函数
* @param priority 优先级
* @param runnable 任务对象
*/
public PrioriRunnable(Priority priority, Runnable runnable) {
this.priority = priority == null ? Priority.NORMAL : priority;
this.runnable = runnable;
}

@Override
public void run() {
this.runnable.run();
}
}3、最后需要创建一个类来实现 ThreadPoolExecutor 来对线程进行管理

import android.support.annotation.NonNull;

import java.util.Comparator;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

/**
* 线程管理类
* @author 49829
* @date 2017/12/5
*/

public class MySelfExecutor extends ThreadPoolExecutor{
/**
* 核心线程池大小（默认大小为5）
*/
private static final int CORE_POOL_SIZE = 5;
/**
* 最大线程池队列大小
*/
private static final int MAXIMUM_POOL_SIZE = 128;
/**
* 保持存活时间，当线程数大于corePoolSize的空闲线程能保持的最大时间。
*/
private static final int KEEP_ALIVE = 1;
/**
* 主要获取添加任务
*/
private static final AtomicLong SEQ_SEED = new AtomicLong(0);

private static final ThreadFactory factory=new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
@Override
public Thread newThread(@NonNull Runnable runnable) {
return new Thread(runnable, "线程"+String.valueOf(mCount.getAndDecrement()));
}
};

/**
* 线程队列方式 先进先出
*/
private static final Comparator<Runnable> FIFO = new Comparator<Runnable>() {
@Override
public int compare(Runnable lhs, Runnable rhs) {
if (lhs instanceof PrioriRunnable && rhs instanceof PrioriRunnable) {
PrioriRunnable lpr = ((PrioriRunnable) lhs);
PrioriRunnable rpr = ((PrioriRunnable) rhs);
int result = lpr.priority.ordinal() - rpr.priority.ordinal();
return result == 0 ? (int) (lpr.SEQ - rpr.SEQ) : result;
} else {
return 0;
}
}
};

/**
* 线程队列方式 后进先出
*/
private static final Comparator<Runnable> LIFO = new Comparator<Runnable>() {
@Override
public int compare(Runnable lhs, Runnable rhs) {
if (lhs instanceof PrioriRunnable && rhs instanceof PrioriRunnable) {
PrioriRunnable lpr = ((PrioriRunnable) lhs);
PrioriRunnable rpr = ((PrioriRunnable) rhs);
int result = lpr.priority.ordinal() - rpr.priority.ordinal();
return result == 0 ? (int) (rpr.SEQ - lpr.SEQ) : result;
} else {
return 0;
}
}
};
/**
* 默认工作线程数5
*
* @param fifo 优先级相同时, 等待队列的是否优先执行先加入的任务.
*/
public MySelfExecutor(boolean fifo) {
this(CORE_POOL_SIZE, fifo);
}

/**
* @param poolSize 工作线程数
* @param fifo     优先级相同时, 等待队列的是否优先执行先加入的任务.
*/
public MySelfExecutor(int poolSize, boolean fifo) {
this(poolSize, MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, new PriorityBlockingQueue<Runnable>(MAXIMUM_POOL_SIZE, fifo ? FIFO : LIFO), factory);
}

public MySelfExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
}

/**
* 判断当前线程池是否繁忙
* @return
*/
public boolean isBusy() {
return getActiveCount() >= getCorePoolSize();
}

/**
* 提交任务
* @param runnable
*/
@Override
public void execute(Runnable runnable) {
if (runnable instanceof PrioriRunnable) {
((PrioriRunnable) runnable).SEQ = SEQ_SEED.getAndIncrement();
}
super.execute(runnable);
}

}

使用时只需要实例化 一个 MySelfExecutor 调用其 execute(Runnable runnable) 方法就可以实现一个简单的线程池管理。