Android 学习线程池ThreadPoolExecutor
ThreadPoolExecutor构造方法
@Test
public void ThreadPoolTest() {
ExecutorService executor = new ThreadPoolExecutor(
//corePoolSize:核心线程数
3,
//maximumPoolSize:最大线程数
5,
//空闲线程最大闲置时间 keepAliveTime:时间的值， unit:时间的单位 例如秒
10L, TimeUnit.SECONDS,
//用于保存任务的队列，可以为无界、有界、同步移交三种队列类型之一，
// 当池子里的工作线程数大于corePoolSize时，这时新进来的任务会被放到队列中
//一共有3种:
//SynchronousQueue(同步移交队列)：队列不作为任务的缓冲方式，可以简单理解为队列长度为零
//LinkedBlockingQueue(无界队列)：队列长度不受限制，当请求越来越多时(任务处理速度跟不上任务提交速度造成请求堆积)
// 可能导致内存占用过多或OOM
//ArrayBlockintQueue(有界队列)：队列长度受限，当队列满了就需要创建多余的线程来执行任务
new ArrayBlockingQueue<>(3),
//创建线程的工厂类，默认使用Executors.defaultThreadFactory()，也可以使用guava库的ThreadFactoryBuilder来创建
Executors.defaultThreadFactory(),
//拒绝策略：
//线程池无法继续接收任务(队列已满且线程数达到maximunPoolSize)时的饱和策略，
// 取值有
// AbortPolicy、中断抛出异常
// CallerRunsPolicy、默默丢弃任务，不进行任何通知
// DiscardOldestPolicy、丢弃掉在队列中存在时间最久的任务
// DiscardPolicy 让提交任务的线程去执行任务(对比前三种比较友好一丢丢)
new ThreadPoolExecutor.AbortPolicy()
);
System.out.println("开始执行线程里面的线程");
for (int i = 0; i < 6; i++) {
executor.execute(() -> {
System.out.println(Thread.currentThread().getName() + ":正在执行任务");
});
}
executor.shutdown();
System.out.println("线程执行结束");
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
Okhttp源码中关于线程池的使用 在Dispatcher里面
public synchronized ExecutorService executorService() {
if (executorService == null) {
//corePoolSize=0，maxPoolSize为很大的数，同步移交队列，也就是说不维护常驻线程(核心线程)，
// 每次来请求直接创建新线程来处理任务，也不使用队列缓冲，会自动回收多余线程，
// 由于将maxPoolSize设置成Integer.MAX_VALUE，
// 当请求很多时就可能创建过多的线程，导致资源耗尽OOM
//这里可以调用Executors的方法达到同样的效果
// public static ExecutorService newCachedThreadPool() {
// return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
// 60L, TimeUnit.SECONDS,
// new SynchronousQueue<Runnable>());
// }
executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));
}
return executorService;
}
Worker
ThreadPoolExecutor的execute()跳入进去发现会有一个新的类Worker。Worker维护了一个thread和一个Runnable，运行时调用ThreadPoolExecutor的runWorker()方法
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable {
final Thread thread;
Runnable firstTask;
//构造方法
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker 在运行Worker之前禁止中断
this.firstTask = firstTask;
//获取创建线程的工厂产生一个线程
this.thread = getThreadFactory().newThread(this);
}
//将run方法交给ThreadPoolExecutor的runWorker调用
public void run() {
runWorker(this);
}
}
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;//将Worker里面要执行的Runnable交给task
w.firstTask = null;
w.unlock(); // allow interrupts 先解锁Worker
try {
while (task != null || (task = getTask()) != null) {
w.lock();//给Worker加锁
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
//翻译：
// 如果池正在停止，确保线程被中断；
//如果没有，确保线程没有中断。这
//在第二种情况下需要重新检查才能处理
//在清除中断的同时停止运转
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);//开始执行
Throwable thrown = null;
try {
task.run();
} catch (Throwable x) {
//...
} finally {
afterExecute(task, thrown);//执行结束之后调用
}
} finally {
task = null;
w.completedTasks++;
w.unlock();//解锁
}
}
}
}
ThreadPoolExecutor的executor()方法添加Worker
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* 有3种情况
* 1.运行线程数少于核心线程数，那么Worker就是一个firstTask
*
* 2.如果运行线程大于核心线程。就会判断是否有已经运行结束的线程，
* 如果有就拿来使用，如果没有就创建新线程
*
* 3. 如果排队的任务也就是BlockingQueue队列满了就会执行拒绝策略
*/
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
