Java线程池
目录
线程池
线程池ThreadPoolExecutor源码剖析
// ExecutorService executorService = Executors.newFixedThreadPool(1);
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2,
4,
10,
TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<>(2),
new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setName("abc");
return t;
}
},
new ThreadPoolExecutor.AbortPolicy());
//线程池执行任务
executor.execute(() ->{
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
});
一、Java构建线程的方法
- 实现Runnable
- 继承Thread
- 实现Callable
- 有返回值return，可以抛出异常
- 线程池方式
- 优点：避免频繁创建线程和销毁线程带来的损耗
- Java提供了构建线程池的的方式，用 Executors 可以去创建（但是规范中不允许使用这种方式创建线程池，这种方式对线程的控制力度比较低）
- 推荐手动创建线程池
二、线程池的7个参数
七个参数：
| 参数 | 解释 |
| corePoolSize | 核心线程数 |
| maximumPoolSize | 最大线程数 |
| keepAliveTime | 最大空闲时间 |
| TimeUnit | 时间单位 |
| BlockingQueue<Runnable> | 阻塞队列 |
| ThreadFactory | 线程工厂 |
| RejectedExecutionHandler | 拒绝策略 |
三、线程池的执行流程
为什么要先进阻塞再去尝试创建非核心线程：
eg：饭店（线程池）--- 厨师（线程）---人多先排队（阻塞队列）---招厨师（创建最大线程数）---客满（拒绝策略）
四、线程池属性标识
4.1.核心属性
//是一个int类型的数值，表达了两个意思，1：声明当前线程池的状态，2：声明线程池中的线程数
//高3位：线程池状态 低29位：线程池中的线程个数
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); //固定值，29，方便后面做位运算 private static final int COUNT_BITS = Integer.SIZE - 3; //通过位运算得出最大容量 private static final int CAPACITY = (1 << COUNT_BITS) - 1; // 线程池状态 //111 代表线程池为 RUNNING ，代表正常接收任务 private static final int RUNNING = -1 << COUNT_BITS; //000 代表线程池为 SHUTDOWN 状态，不接收新任务，但是内部还会处理阻塞队列中的任务，正在进行的任务也正常处理 private static final int SHUTDOWN = 0 << COUNT_BITS; //001 代表线程池为 STOP 状态，不接收新任务，也不去处理阻塞队列中的任务，同时会中断正在执行的任务 private static final int STOP = 1 << COUNT_BITS; //010 代表线程池为 TIDYING 状态，过渡的状态，代表当前线程池即将Game over private static final int TIDYING = 2 << COUNT_BITS; //011 代表线程池为 TERMINATED ，要执行terminated()，凉透了 private static final int TERMINATED = 3 << COUNT_BITS; // 得到线程池的状态 private static int runStateOf(int c) { return c & ~CAPACITY; } // 得到当前线程池的线程数量 private static int workerCountOf(int c) { return c & CAPACITY; }
4.2.线程池状态变化
线程池的状态可以通过ThreadPoolExecutor类的getPoolSize()方法，getActiveCount()方法，getCompletedTaskCount()方法和getTaskCount()方法来查询。线程池的状态有以下几种：
1. Running（运行状态）：线程池新建或调用execute()方法后，处于运行状态，能够接收新的任务。
2. Shutdown（关闭状态）：线程池调用shutdown()方法后，线程池的状态会变为Shutdown。此时线程池不再接收新的任务，但会执行已提交的等待任务队列中的任务。
3. Stop（停止状态）：人为调用shutdownNow()方法后，线程池的状态会变为Stop。此时线程池不再接收新的任务，并且会中断正在处理中的任务。
4. Tidying（整理状态）：当线程池处于Shutdown或Stop状态时，如果等待队列中还有未执行的任务，则线程池将执行整理操作，将等待队列中的未执行任务移除，并保存到一个列表中。
5. Terminated（终止状态）：当线程池处于Shutdown状态，并且等待队列中的任务全部执行完毕，或者在Stop状态下，线程池内部的所有线程都已经终止时，线程池进入Terminated状态。
线程池的状态变化如上所述，可以更好地对线程池进行管理和监控。
五、线程池的 execute 方法执行
从execute方法开始
public void execute(Runnable command) {
//健壮性判断
if (command == null)
throw new NullPointerException();
//拿到32位的int
int c = ctl.get();
//获取 工作线程数 < 核心线程数
if (workerCountOf(c) < corePoolSize) {
//进到if，代表可以创建核心线程数
if (addWorker(command, true))
//到这结束
return;
//如果if没进去，代表创建核心线程数失败，重新获取ctl 32位的int
c = ctl.get();
}
//判断线程池是不是RUNNING,将任务添加到阻塞队列中的
if (isRunning(c) && workQueue.offer(command)) {
//再次获取ctl
int recheck = ctl.get();
//再次判断是否是RUNNING， 如果不是RUNNING，移除任务
if (! isRunning(recheck) && remove(command))
reject(command);//拒绝策略
//如果线程处在 RUNNING 状态，但是工作线程为0
else if (workerCountOf(recheck) == 0)
addWorker(null, false);//阻塞队列有任务，但是没有工作线程，添加一个任务为空的工作线程处理阻塞队列中的任务
}
//创建非核心线程，处理任务
else if (!addWorker(command, false))
reject(command);//拒绝策略
}
通过上述源码，掌握了线程池的执行流程，再次查看 addWorker 方法内部做了什么处理。
private boolean addWorker(Runnable firstTask, boolean core) {
//标记for循环
retry:
//经过大量的判断，给工作线程数标识 +1；
for (;;) {
//获取ctl （32位）
int c = ctl.get();
//获取线程池状态
int rs = runStateOf(c);
if (rs >= SHUTDOWN && // 除了RUNNING都有可能
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty())
// rs == SHUTDOWN ，就代表是STOP或者更高的状态，这时，不需要添加线程处理任务
// 任务为空，如果任务位 null，并且线程池状态不是 RUNNING ,不需要处理
// 阻塞队列不为null ，如果阻塞队列为空，返回 false ，外侧的 ！ 再次取反，获取 true，不需要处理
)
//构建工作线程失败！
return false;
for (;;) {
//获取工作线程个数
int wc = workerCountOf(c);
//如果当前线程已经大于线程池最大容量，不去创建了
if (wc >= CAPACITY ||
// 判断wc是否超过核心线程或者最大线程
wc >= (core ? corePoolSize : maximumPoolSize))
//构建工作线程失败！
return false;
// 将工作线程数+1 ， 采用CAS的方式
if (compareAndIncrementWorkerCount(c))
//成功就退出外侧 for 循环
break retry;
// 重新获取ctl
c = ctl.get();
//重新判断线程池状态 如果状态没变化：重新执行内部循环即可
if (runStateOf(c) != rs)
//如果状态有变化：结束这次外侧循环，开始下次外侧循环
continue retry;
}
}
// worker 开始
boolean workerStarted = false;
boolean workerAdded = false;
//Worker 就是工作线程
Worker w = null;
try {
//创建Worker，传入任务
w = new Worker(firstTask);
//从Worker中获取线程t
final Thread t = w.thread;
//如果线程 t 不为null
if (t != null) {
//获取线程池的全局锁，避免我添加任务时，其他线程干掉了线程池，干掉线程池需要先获得这个锁
final ReentrantLock mainLock = this.mainLock;
//加锁
mainLock.lock();
try {
//获取线程池状态
int rs = runStateOf(ctl.get());
//是RUNNING状态
if (rs < SHUTDOWN ||
//是SHUTDOWN状态，创建空任务工作线程，处理阻塞队列中的任务
(rs == SHUTDOWN && firstTask == null)) {
//线程是否是运行状态
if (t.isAlive())
throw new IllegalThreadStateException();
//将工作线程添加到集合中
workers.add(w);
//获取工作线程个数
int s = workers.size();
//如果现在工作线程数，大于之前记录的最大工作线程数，就替换一下
if (s > largestPoolSize)
largestPoolSize = s;
//workerAdded 为true，添加工作线程成功
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
//启动工作线程
t.start();
//启动工作线程成功
workerStarted = true;
}
}
} finally {
//如果启动工作线程失败，就调用下面的方法
if (! workerStarted)
addWorkerFailed(w);
}
//返回工作是否启动
return workerStarted;
}
六、Worker的封装
Worker的封装（源码）
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
final Thread thread;
Runnable firstTask;
volatile long completedTasks;
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
看 runWorker 方法
final void runWorker(Worker w) {
//获取当前线程
Thread wt = Thread.currentThread();
//拿到任务
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
//标识为true
boolean completedAbruptly = true;
try {
//任务不空，执行任务。 如果任务为空，通过getTask从阻塞队列中获取任务！
while (task != null || (task = getTask()) != null) {
//加锁，避免你shutdown我任务也不会中断
w.lock();
//获取当前状态，是否大于等于STOP,被拒！
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 (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
//执行任务后的操作
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
浙公网安备 33010602011771号