线程
线程是调度CPU资源的最小单位，线程模型分为KLT和ULT模型，JVM使用的KLT模型java线程与OS线程保持1:1的映射关系，也就是说每一个java线程对应操作系统一个线程。Java线程有以下几种生命状态：
- NEW：新建状态
- RUNNABLE：运行状态
- READY：就绪状态
- RUNNING：运行中
- BLOCKED：阻塞状态
- WAITING：等待状态
- TIMED_WAITING：超时等待状态
- TERMINATED：终结状态
状态之间的切换过程如图：
线程池
是一个线程缓存，因为线程是稀缺资源，如果被无限创建，不仅会消耗系统资源，还会降低系统的稳定性，因此Java中提供了线程池对现成进行统一的分配、调优和监控。
线程池介绍
例如Web开发中，服务器需要接受并处理来自外部的请求，所以会为每一个请求分配一个线程来处理。如果每次请求都新建一个线程的话实现方式很简单，但是存在一些问题：
- 如果并发的请求数量非常高，而且单个请求线程执行的时间非常短，就会出现频繁的创建和销毁线程，如此会大大降低系统的效率，因为可能会出现服务器为每个请求创建先线程和销毁线程上花费系统资源要比处理实际的用户请求的时间和资源更多；
- 系统可以支持创建的线程数量也是有上限的(每个线程实际对应的一个操作系统文件描述符)；
基于上述问题，线程池为线程生命周期的开销和资源不足提供了统一的解决方案，通过对多个任务重用线程，线程创建的开销被分摊到多个任务上；
线程池适用的场景
- 单个任务处理时间比较短；
- 需要处理的任务数据量很大；
线程池优势
- 重用存在的线程，减少线程创建、销毁的开销；
- 提高响应速度。当任务到达时，任务可以不需要等待线程创建就可以立即运行；
- 提高线程的可管理性。现成是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控。
线程实现方式
-
Runable：实现runnable接口的类，将被Thread执行，表示一个基本的任务，其中实现的run方法就是实际执行的任务；没有返回结果；
-
Callable：与Runnable接口的区别是call方法可以接收一个泛型，同时执行任务后返回需要的泛型；
-
Thread：直接new一个线程；
Executor框架
Executor接口是线程池框架中最基础的部分，定义了一个用于Runnable的execute方法。
Executor下有一个重要的子接口ExecutorService，其中定义了线程池的具体行为：
- execute(Runnable command)：执行Runnable类型的任务，没有返回结果；
- submit(task)：可以用来提交Callable或Runnable任务，并返回代表此任务的Future对象；
- shutdown()：在执行完已经提交的task后，关闭线程池调度，不再接收新的任务提交；
- shutdownNow()：停止所有正在执行的任务，并且不再接收新的任务提交；
- isTerminated()：检查是否全部任务都已经执行完成；
- isShutdow()：检查是否该ExecutorService已经被关闭；
线程池重点属性
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING,0));
private static final int COUNT_BITS = Integer.SIZE-3;
private static final int CAPACITY = (1<<COUNT_BITS) -1;ctl变量是对象城池的运行状态和线程池中有效线程的数量进行控制的一个字段，它包含两部分信息：线程池的运行状态(runState)和线程池内有效线程的数量(workCount)，其中使用了Integer类型进行保存，高3位保存runState，低29位保存workerCount。Count_BITS就是29，CAPACITY就是1左移29位后-1，表示workCount的上限值，大约是5亿。
ctl相关方法
private static int runStateOf(int c){return c&~CAPACITY;}
private static int workCountOf(int c){return c&CAPACITY;}
private static int ctlOf(int rs,int wc){return rs|wc;}- runStateOf：获取线程运行状态；
- workerCountOf：获取活动线程数；
- ctrlOf：获取运行状态和活动线程数的值；
线程池的5种状态
RUNNING = -1 << COUNT_BITS; // 高3位为111
SHUTDOWN = 0 << COUNT_BITS; // 高3位为000
STOP = 1 << COUNT_BITS; // 高3位为001
TIDYING = 2 << COUNT_BITS; // 高3位为010
TERMINATED = 3 << COUNT_BITS; // 高3位为011- RUNNING
- 状态说明：线程处于RUNNING状态时，可以接收新任务，以及对已经添加的任务进行处理；
- 状态切换：线程池的初始状态就是RUNNING，线程池一旦创建就处于RUNNING，并且线程池中的任务数为0；
- SHUTDOWN
- 状态说明：线程池处于SHUTDOWN状态时，不接受新任务，但能处理已添加的任务；
- 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING=>SHUTDOWN.
- STOP
- 状态说明：现成处于STOP状态时，不接收新任务，不处理已经添加的任务，并且会中断正在处理的任务；
- 状态切换：调用线程池的shutdownNow()接口时，线程池由RUNNING or SHUTDOWN =>STOP;
- TIDYING
- 状态说明：当所有的任务已终止，ctl记录的任务数量为0，线程池会变成TIDYING状态。当线程池状态变成TIDYING时，会执行钩子函数terminated().terminated()；在ThreadPoolExecutor类中是空的，若用户想在线程池变成TIDYING时，进行后续的处理，可以通过重写terminated函数来实现；
- 状态切换：
- 当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由SHUTDOWN=>TIDYING
- 当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP=>TIDYING
- TERMINATED
- 状态说明：线程池彻底终止，就会变成TERMINATED状态；
- 状态切换：线程池处于TIDYING状态时，执行完terminated()之后，就会由TIDYING=>TERMINATED
- 进入TERMINATED的条件如下：
- 线程池不是RUNNING；
- 线程池状态不是TIDYING状态或TERMINATED；
- 如果线程池状态是SHUTDOWN并且workQueue为空；
- workCount为0；
- 设置TIDYING状态成功；
线程池的几个具体实现
- ThreadPoolExecutor 普通线程池
- ScheduledThreadPoolExecutor 定时线程池
ThreadPoolExecutor
构造函数：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)提交任务的方法：
public void execute(); // 提交任务，无返回值
public Future<?> submit();// 提交任务，执行完成后有返回值构造函数参数解析
- corePoolSize：
- 线程池中的核心线程数，当提交一个任务时，线程池中创建一个新线程并且执行当前任务，直到当前线程数等于corePoolSize；
- 如果当前线程数为corePoolSize,后续提交的任务会被保存至阻塞队列中，等待有空闲线程时被调度执行；
- 如果执行了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有核心线程。
- maximumPoolSize：
- 线程池中允许创建的最大线程数。如果当前阻塞队列满了，且继续提交任务，则创建新的线程执行任务，前提是当前线程数小于maximumPoolSize;
- keepAliveTime
- 线程池维护线程所允许的空闲时间。当线程池中的线程数大于corePoolSize，且没有新任务继续提交，核心线程外的线程不会立即销毁，而是会等待超过keepAliveTime后再销毁非核心线程；
- unit
- keepAliveTime的单位；
- workQueue
- 用来保存等待被执行的任务的阻塞队列，且任务必须实现Runnable接口，在JDK中提供了如下阻塞队列：
- ArrayBlockingQueue：基于数组结构结构的有界阻塞队列，FIFO排序；
- LinkedBlockingQueue：基于链表结构的阻塞队列，按FIFO排序，吞吐量通常要高于ArrayBlockingQueue；
- SynchronousQueue：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue；
- prorityBlockingQueue：具有优先级的无界队列；
- threadFactory
- 它是ThreadFactory类型的变量，用来创建新线程，默认使用Executors.defaultThreadFactory()来创建线程具有相同的NORM_PRIORITY优先级并且是非守护线程，同时设置了线程名称；
- handler
- 线程池的饱和策略，当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种处理该任务，线程池提供了4种策略：
- AbortPolicy：直接抛出异常，默认策略；
- CallRunsPolicy：用调用者所在的线程执行任务；
- DiscardOldestPolicy：丢弃阻塞队列中最靠前的任务，并执行当前任务；
- DiscardPolicy：直接丢弃任务；
- 以上4种策略都是ThreadPoolExecutor的内部类。当然也可以根据应用场景实现RejectExecutionHandler接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务；
- 线程池的饱和策略，当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种处理该任务，线程池提供了4种策略：
- 用来保存等待被执行的任务的阻塞队列，且任务必须实现Runnable接口，在JDK中提供了如下阻塞队列：
线程池监控
public long getTaskCount();// 线程池已执行与未执行的任务总数
public long getCompletedTaskCount();// 已经完成的任务数
public int getPoolSize(); // 线程池当前的线程数
public int getActiveCount();// 线程池中正在执行任务的线程数 线程池原理
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* clt记录着runState和workerCount
*/
int c = ctl.get();
/*
* workerCountOf方法取出低29位的值，表示当前活动的线程数；
* 如果当前活动线程数小于corePoolSize，则新建一个线程放入线程池中；
* 并把任务添加到该线程中。
*/
if (workerCountOf(c) < corePoolSize) {
/*
* addWorker中的第二个参数表示限制添加线程的数量是根据corePoolSize来判断还是maximumPoolSize来判断；
* 如果为true，根据corePoolSize来判断；
* 如果为false，则根据maximumPoolSize来判断
*/
if (addWorker(command, true))
return;
/*
* 如果添加失败，则重新获取ctl值
*/
c = ctl.get();
}
/*
* 如果当前线程池是运行状态并且任务添加到队列成功
*/
if (isRunning(c) && workQueue.offer(command)) {
// 重新获取ctl值
int recheck = ctl.get();
// 再次判断线程池的运行状态，如果不是运行状态，由于之前已经把command添加到workQueue中了，
// 这时需要移除该command
// 执行过后通过handler使用拒绝策略对该任务进行处理，整个方法返回
if (! isRunning(recheck) && remove(command))
reject(command);
/*
* 获取线程池中的有效线程数，如果数量是0，则执行addWorker方法
* 这里传入的参数表示：
* 1. 第一个参数为null，表示在线程池中创建一个线程，但不去启动；
* 2. 第二个参数为false，将线程池的有限线程数量的上限设置为maximumPoolSize，添加线程时根据maximumPoolSize来判断；
* 如果判断workerCount大于0，则直接返回，在workQueue中新增的command会在将来的某个时刻被执行。
*/
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
/*
* 如果执行到这里，有两种情况：
* 1. 线程池已经不是RUNNING状态；
* 2. 线程池是RUNNING状态，但workerCount >= corePoolSize并且workQueue已满。
* 这时，再次调用addWorker方法，但第二个参数传入为false，将线程池的有限线程数量的上限设置为maximumPoolSize；
* 如果失败则拒绝该任务
*/
else if (!addWorker(command, false))
reject(command);
}execute方法执行流程如下：
addWorker方法解读
boolean addWorker(Runnable firstTask, boolean core)方法的主要工作是在线程池中创建一个新的线程并且执行任务，
- firstTask参数用于指定新增线程指定的第一个任务，
- core参数
- true表示新增线程时会判断当前活动线程数是否少于corePoolSiz；
- false表示新增线程需要判断当前活动线程数是否少于maximumPoolSize；
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
// 获取运行状态
int rs = runStateOf(c);
/*
* 这个if判断
* 如果rs >= SHUTDOWN，则表示此时不再接收新任务；
* 接着判断以下3个条件，只要有1个不满足，则返回false：
* 1. rs == SHUTDOWN，这时表示关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务
* 2. firsTask为空
* 3. 阻塞队列不为空
*
* 首先考虑rs == SHUTDOWN的情况
* 这种情况下不会接受新提交的任务，所以在firstTask不为空的时候会返回false；
* 然后，如果firstTask为空，并且workQueue也为空，则返回false，
* 因为队列中已经没有任务了，不需要再添加线程了
*/
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
// 获取线程数
int wc = workerCountOf(c);
// 如果wc超过CAPACITY，也就是ctl的低29位的最大值（二进制是29个1），返回false；
// 这里的core是addWorker方法的第二个参数，如果为true表示根据corePoolSize来比较，
// 如果为false则根据maximumPoolSize来比较。
//
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 尝试增加workerCount，如果成功，则跳出第一个for循环
if (compareAndIncrementWorkerCount(c))
break retry;
// 如果增加workerCount失败，则重新获取ctl的值
c = ctl.get(); // Re-read ctl
// 如果当前的运行状态不等于rs，说明状态已被改变，返回第一个for循环继续执行
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 根据firstTask来创建Worker对象
w = new Worker(firstTask);
// 每一个Worker对象都会创建一个线程
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int rs = runStateOf(ctl.get());
// rs < SHUTDOWN表示是RUNNING状态；
// 如果rs是RUNNING状态或者rs是SHUTDOWN状态并且firstTask为null，向线程池中添加线程。
// 因为在SHUTDOWN时不会在添加新的任务，但还是会执行workQueue中的任务
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// workers是一个HashSet
workers.add(w);
int s = workers.size();
// largestPoolSize记录着线程池中出现过的最大线程数量
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
// 启动线程
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}Worker类
public class ThreadPoolExecutor extends AbstractExecutorService {
/**
* Set containing all worker threads in pool. Accessed only when
* holding mainLock.
*/
private final HashSet<Worker> workers = new HashSet<Worker>();private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
/**
* This class will never be serialized, but we provide a
* serialVersionUID to suppress a javac warning.
*/
private static final long serialVersionUID = 6138294804551838833L;
/** Thread this worker is running in. Null if factory fails. */
final Thread thread;
/** Initial task to run. Possibly null. */
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;线程池中每一个线程被封装成一个Worker对象，ThreadPool维护了一个Worker数组；Worker继承了AQS,并且实现了Runnabel接口，其中firstTask和thread属性说明：
- firstTask用来保存传入的任务；
- thread是在调用构造方法时通过ThreadFactory创建的线程，用来处理当前任务的线程；
在调用构造方法时，需要把任务传入，这里通过getThreadFactory().newThread(this);来新建一个线程，newThread方法传入的参数是this，因为worker本身继承了Runnable接口，也就是一个线程，所以一个Worker对象在启动的时候会调用Worker类中的run方法。
Worker继承AQS，使用AQS来实现独占锁的功能，为什么不使用ReetrantLock来实现呢？可以看到tryAcquire方法，它是不允许冲入的，而ReetrantLock是允许重入的；
- lock方法一旦获取了独占锁，表示当前线程正在执行任务中；
- 如果正在执行任务，则不应该中断线程；
- 如果该线程现在不是独占锁的状态，即空闲状态，说明它没有处理任务，这时可以对该线程进行中断；
- 线程池在执行shutdown方法或者tryTerminate方法时会调用interuptIdleWorkers方法来中断空闲的线程，interruptIdelWorkers方法会使用tryLock方法来判断线程池中的线程是否是空闲状态；
- 之所以设置为不可重入，是因为我们不希望任务在调用像setCorePoolSize这样的线程池控制方法时重新获取锁。如果使用ReetrantLock，它是可以重入的，这样如果在任务中调用了如setCorePoolSize这类线程池控制方法，会中断正在运行的线程；
综上所述，Worker继承自AQS，用于判断是否空闲以及是否可以被中断。
此外，在构造方法中执行了setState(-1),把state变量设置为-1，为什么这么做呢？是因为AQS中默认的state是0，如果刚创建一个Worker对象，还没执行时，这时就不应该被中断，例如tryAcquire方法：
protected boolean tryAcquire(int unused) {
//cas修改state，不可重入
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}tryAcquire方法是根据state是否是0来判断的，所以setState(-1)将state设置为-1是为了禁止在执行任务前对线程进行中断；同时，在runWorker方法中会调用Worker对象的unlock方法将state设置为0；
runWorker方法
在Worker类中的run方法调用了runWorker方法来执行任务，runWorker方法的代码如下：
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
// 获取第一个任务
Runnable task = w.firstTask;
w.firstTask = null;
// 允许中断
w.unlock(); // allow interrupts
// 是否因为异常退出循环
boolean completedAbruptly = true;
try {
// 如果task为空，则通过getTask来获取任务
while (task != null || (task = getTask()) != null) {
w.lock();
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);
}
}简单总结一下runWorker方法的执行过程：
- while循环不断地通过getTask()方法获取任务；
- getTask()方法从阻塞队列中获取任务；
- 如果线程池正在停止，那么保证当前线程是中断状态，否则要保证当前线程不是中断状态；
- 调用task.run()执行任务；
- 如果task为null则跳出循环，执行processWorkerExit()方法；
- runWorker方法执行完毕，也代表Worker中的run方法执行完毕，销毁线程；
getTask方法
private Runnable getTask() {
// timeOut变量的值表示上次从阻塞队列中取任务时是否超时
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
/*
* 如果线程池状态rs >= SHUTDOWN，也就是非RUNNING状态，再进行以下判断：
* 1. rs >= STOP，线程池是否正在stop；
* 2. 阻塞队列是否为空。
* 如果以上条件满足，则将workerCount减1并返回null。
* 因为如果当前线程池状态的值是SHUTDOWN或以上时，不允许再向阻塞队列中添加任务。
*/
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
// timed变量用于判断是否需要进行超时控制。
// allowCoreThreadTimeOut默认是false，也就是核心线程不允许进行超时；
// wc > corePoolSize，表示当前线程池中的线程数量大于核心线程数量；
// 对于超过核心线程数量的这些线程，需要进行超时控制
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
/*
* wc > maximumPoolSize的情况是因为可能在此方法执行阶段同时执行了setMaximumPoolSize方法；
* timed && timedOut 如果为true，表示当前操作需要进行超时控制，并且上次从阻塞队列中获取任务发生了超时
* 接下来判断，如果有效线程数量大于1，或者阻塞队列是空的，那么尝试将workerCount减1；
* 如果减1失败，则返回重试。
* 如果wc == 1时，也就说明当前线程是线程池中唯一的一个线程了。
*/
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
/*
* 根据timed来判断，如果为true，则通过阻塞队列的poll方法进行超时控制，如果在keepAliveTime时间内没有获取到任务，则返回null；
* 否则通过take方法，如果这时队列为空，则take方法会阻塞直到队列不为空。
*
*/
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
// 如果 r == null，说明已经超时，timedOut设置为true
timedOut = true;
} catch (InterruptedException retry) {
// 如果获取任务时当前线程发生了中断，则设置timedOut为false并返回循环重试
timedOut = false;
}
}
}关注第2个if判断，目标是控制线程池的有效数量。由上文中代码分析可以知道：
执行execute方法时，如果当前线程池的线程数量超过corePoolSize且小于maximumPoolSize，并且workQueue已满，则可以增加工作线程，但这是如果超时没有获取到任务，也就是timeOut为true的情况，说明workerQueue为空，即当前线程池中已经不需要这么多的线程执行任务了，可以把大于corePoolSize数量的线程销毁，保证线程数量在corePoolSize即可；
空闲线程销毁时机
在runWorker方法执行完成之后，即Worker的run方法执行完，由JVM自动回收，getTask方法返回null时，在runWorker方法中会跳出while循环，然后执行processWorkerExit方法。
processWorkerExit方法
private void processWorkerExit(Worker w, boolean completedAbruptly) {
// 如果completedAbruptly值为true，则说明线程执行时出现了异常，需要将workerCount减1；
// 如果线程执行时没有出现异常，说明在getTask()方法中已经已经对workerCount进行了减1操作，这里就不必再减了。
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//统计完成的任务数
completedTaskCount += w.completedTasks;
// 从workers中移除，也就表示着从线程池中移除了一个工作线程
workers.remove(w);
} finally {
mainLock.unlock();
}
// 根据线程池状态进行判断是否结束线程池
tryTerminate();
int c = ctl.get();
/*
* 当线程池是RUNNING或SHUTDOWN状态时，如果worker是异常结束，那么会直接addWorker；
* 如果allowCoreThreadTimeOut=true，并且等待队列有任务，至少保留一个worker；
* 如果allowCoreThreadTimeOut=false，workerCount不少于corePoolSize。
*/
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
addWorker(null, false);
}
}processWorkerExit执行完之后，工作线程被销毁，以上就是整个工作线程的生命周期，从execute方法开始，Worker使用ThreadFactory创建新工作线程，runWorker通过getTask获取任务，然后执行任务，如果getTask返回null，进入processWorkerExit方法，整个线程结束，如图所示：
常见操作比对
| 方法 | 说明 |
| sleep |
|
| wait |
|
| yield |
|
| join |
|
