前言
線程并發(fā)系列文章：
Java 線程基礎(chǔ)
Java 線程狀態(tài)
Java “優(yōu)雅”地中斷線程-實踐篇
Java “優(yōu)雅”地中斷線程-原理篇
真正理解Java Volatile的妙用
Java ThreadLocal你之前了解的可能有誤
Java Unsafe/CAS/LockSupport 應(yīng)用與原理
Java 并發(fā)"鎖"的本質(zhì)(一步步實現(xiàn)鎖)
Java Synchronized實現(xiàn)互斥之應(yīng)用與源碼初探
Java 對象頭分析與使用(Synchronized相關(guān))
Java Synchronized 偏向鎖/輕量級鎖/重量級鎖的演變過程
Java Synchronized 重量級鎖原理深入剖析上(互斥篇)
Java Synchronized 重量級鎖原理深入剖析下(同步篇)
Java并發(fā)之 AQS 深入解析(上)
Java并發(fā)之 AQS 深入解析(下)
Java Thread.sleep/Thread.join/Thread.yield/Object.wait/Condition.await 詳解
Java 并發(fā)之 ReentrantLock 深入分析(與Synchronized區(qū)別)
Java 并發(fā)之 ReentrantReadWriteLock 深入分析
Java Semaphore/CountDownLatch/CyclicBarrier 深入解析(原理篇)
Java Semaphore/CountDownLatch/CyclicBarrier 深入解析(應(yīng)用篇)
最詳細的圖文解析Java各種鎖(終極篇)
線程池必懂系列
前面幾篇文章深入分析了Thread、synchronized、AQS等相關(guān)知識，基礎(chǔ)打好了，接下來就來分析常見的幾個方法的應(yīng)用、原理及其容易混淆的地方。
通過本篇文章，你將了解到：
1、Thread.sleep 應(yīng)用及原理
2、Thread.yield 應(yīng)用及原理
3、Thread.join 應(yīng)用及原理
4、Object.wait 應(yīng)用及原理
5、Condition.await 應(yīng)用及原理
6、總結(jié)
1、Thread.sleep 應(yīng)用及原理
Thread.sleep 應(yīng)用
Thread.sleep 作用：
調(diào)用 Thread.sleep后，線程進入休眠狀態(tài)并讓出CPU，等待超時時間耗盡，再次被CPU 調(diào)度運行。
先來看看Thread.java 里的定義：
public static native void sleep(long millis) throws InterruptedException;
可以看出，其接受一個毫秒為單位的超時時間，并可能拋出InterruptedException 異常。當然也可以通過:
public static void sleep(long millis, int nanos)
throws InterruptedException{...}
追加納秒時間。
來看看Demo:
private void testSleep() {
try {
Thread.sleep(-1);//----->(1)
Thread.sleep(0);//------>(2)
Thread.sleep(1);//------>(3)
} catch (InterruptedException e) {
e.printStackTrace();
}
}
上述代碼標注的(1)/(2)/(3)，分別傳入負數(shù)、0、正數(shù)，結(jié)果分別是什么呢？
(1)
會拋出IllegalArgumentException 異常。
(2)
正常運行。
(3)
休眠1ms后線程得以繼續(xù)執(zhí)行。
Thread.sleep 原理
接著從源碼的角度查看Thread.sleep(xx)接收不同參數(shù)以及為什么可以響應(yīng)中斷。
Thread.sleep(xx)為native方法，先找到其對應(yīng)的jni函數(shù)映射：
#Thread.c
static JNINativeMethod methods[] = {
{"start0", "()V", (void *)&JVM_StartThread},
{"stop0", "(" OBJ ")V", (void *)&JVM_StopThread},
{"isAlive", "()Z", (void *)&JVM_IsThreadAlive},
{"suspend0", "()V", (void *)&JVM_SuspendThread},
{"resume0", "()V", (void *)&JVM_ResumeThread},
{"setPriority0", "(I)V", (void *)&JVM_SetThreadPriority},
{"yield", "()V", (void *)&JVM_Yield},
{"sleep", "(J)V", (void *)&JVM_Sleep},
{"currentThread", "()" THD, (void *)&JVM_CurrentThread},
{"countStackFrames", "()I", (void *)&JVM_CountStackFrames},
{"interrupt0", "()V", (void *)&JVM_Interrupt},
{"isInterrupted", "(Z)Z", (void *)&JVM_IsInterrupted},
{"holdsLock", "(" OBJ ")Z", (void *)&JVM_HoldsLock},
{"getThreads", "()[" THD, (void *)&JVM_GetAllThreads},
{"dumpThreads", "([" THD ")[[" STE, (void *)&JVM_DumpThreads},
{"setNativeName", "(" STR ")V", (void *)&JVM_SetNativeThreadName},
};
再找到C++函數(shù)實現(xiàn)：
#jvm.cpp
JVM_ENTRY(void, JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis))
JVMWrapper("JVM_Sleep");
if (millis < 0) {
//如果傳入的時間為負數(shù)，則拋出IllegalArgumentException 異常
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
}
//如果發(fā)生中斷，則將中斷標記位置為false，然后拋出InterruptedException 異常
if (Thread::is_interrupted (THREAD, true) && !HAS_PENDING_EXCEPTION) {
THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");
}
...
if (millis == 0) {
//傳入的時間為0
//ConvertSleepToYield 表示是否將sleep轉(zhuǎn)為yield，在x86下是true
if (ConvertSleepToYield) {
//調(diào)用系統(tǒng)的yield()函數(shù)
os::yield();
} else {
...
//調(diào)用系統(tǒng)的sleep()函數(shù)，并指定最小的時間MinSleepInterval(1ms)
os::sleep(thread, MinSleepInterval, false);
...
}
} else {
//傳入的時間>0
if (os::sleep(thread, millis, true) == OS_INTRPT) {
//睡眠醒過來后，發(fā)現(xiàn)發(fā)生了中斷，拋出中斷異常
THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");
}
}
thread->osthread()->set_state(old_state);
}
if (event.should_commit()) {
event.set_time(millis);
event.commit();
}
#ifndef USDT2
JVM_END
分析到此處，上面的疑惑基本解開了。
1、Thread.sleep(-1)，傳參是負數(shù)，則拋出異常。
2、Thread.sleep(0)，傳參是0，則調(diào)用Thread.yield()。
3、不是1、2兩點的值，則調(diào)用ParkEvent.park(xx)-->os::Linux::safe_cond_timedwait()-->NPTL.pthread_cond_timedwait(xx) 按照限時時間掛起線程。
4、Thread.sleep(xx)過程中，若是發(fā)生中斷，則拋出中斷異常，并將中斷標記位置為false。
2、Thread.yield 應(yīng)用及原理
Thread.yield 應(yīng)用
Thread.yield 作用：
調(diào)用Thread.yield后，線程讓出CPU，CPU調(diào)度優(yōu)先級比當前線程更高或者優(yōu)先級相等的線程，若沒有則Thread.yield調(diào)用立刻返回。
在并發(fā)場景下，可以提高CPU利用率。
先來看看Thread.java 里的定義：
public static native void yield();
Thread.yield 雖然平時很少用到，但不代表沒用，回顧之前分析AQS源碼時判斷節(jié)點是否在同步同隊列里時的做法：
#AbstractQueuedSynchronizer.java
final boolean transferAfterCancelledWait(Node node) {
...
//不斷檢測是否在同步隊列里
while (!isOnSyncQueue(node))
//沒有無休止地輪訓，而是yield一會
Thread.yield();
return false;
}
比如：線程A往同步隊列里放節(jié)點，線程B查詢，因為A、B并不是嚴格意義上的同步關(guān)系，因此無需用等待/通知機制，B知道A放節(jié)點速度很快，因此B僅僅只需要Thread.yield()簡單讓出CPU即可。
Thread.yield 原理
#jvm.cpp
JVM_ENTRY(void, JVM_Yield(JNIEnv *env, jclass threadClass))
JVMWrapper("JVM_Yield");
//不支持yield，直接返回
//默認是支持的
if (os::dont_yield()) return;
//ConvertYieldToSleep 默認false
if (ConvertYieldToSleep) {
os::sleep(thread, MinSleepInterval, false);
} else {
//調(diào)用系統(tǒng)yield
os::yield();
}
JVM_END
#os_linux.cpp
void os::yield() {
//系統(tǒng)調(diào)度
sched_yield();
}
可以看出，Thread.yield 不響應(yīng)中斷。
3、Thread.join 應(yīng)用及原理
Thread.join 應(yīng)用
Thread.join 作用：
調(diào)用Thread.join后，調(diào)用者線程阻塞等待直到目標線程停止運行后再返回。
可以用來做線程間簡單同步，比如A線程(調(diào)用者線程)等待B(目標線程)執(zhí)行結(jié)束后再做其它動作。
在Thread.java 里的定義：
public final void join() throws InterruptedException(){...}
當然也可以設(shè)置超時時間，若是超時時間耗盡后，目標線程還沒執(zhí)行完畢Thread.join也是可以提前返回的。
//超時單位毫秒
public final synchronized void join(long millis){...}
來看看Demo:
public class TestThread {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t1 執(zhí)行到末尾了");
}
});
t1.start();
System.out.println("等待 t1 執(zhí)行完畢");
t1.join();
System.out.println("t1 執(zhí)行結(jié)束了");
}
}
主線程調(diào)用Thread.join等待t1執(zhí)行完畢。
Thread.join 原理
#Thread.java
public final void join() throws InterruptedException {
//超時時間0
join(0);
}
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
//超時時間必須>=0
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
//此處的wait就是this.wait(0)，也就是thread.wait()
//一直等待，直到收到notify
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
//超時過了，直接返回
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
可以看出，Thread.join借助Object.wait/Object.notify 來實現(xiàn)線程間同步功能的。而且Thread.join 沒有顯式處理中斷的邏輯，但卻聲明需要拋出中斷異常，實際上中斷異常是Object.wait拋出的。
既然有Thread.wait在等待，那么想要Thread.wait返回，那么需要調(diào)用Thread.notify，這個在哪調(diào)用的呢？只能是線程結(jié)束時調(diào)用。
#thread.cpp
//線程結(jié)束，調(diào)用該方法
void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
...
ensure_join(this);
...
}
static void ensure_join(JavaThread* thread) {
...
ObjectLocker lock(threadObj, thread);
...
//喚醒等待在thread對象上的線程
lock.notify_all(thread);
...
}
#ObjectSynchronizer.hpp
void notify_all(TRAPS) { ObjectSynchronizer::notifyall(_obj, CHECK); }
可以看出，線程結(jié)束后最終調(diào)用了thread.notify_all喚醒所有等待它執(zhí)行完成的線程。
因為Thread.join里調(diào)用Object.wait，而Object.wait需要拋出中斷異常，因此Thread.join也需要拋出中斷異常。
4、Object.wait 應(yīng)用及原理
Object.wait 應(yīng)用
Object.wait 作用：
調(diào)用Object.wait 后，線程被阻塞，等待其它線程喚醒它。
用來做線程間的同步。
來看看Object.java里的定義：
public final void wait() throws InterruptedException
可以看出該方法可能會拋出中斷異常。
當然wait(xx)可以設(shè)置超時時間。
public final native void wait(long timeout) throws InterruptedException;
超時時間單位為毫秒(ms)。
看看Demo：
public class TestThread {
public static Object object = new Object();
public static volatile boolean flag = false;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (object) {
try {
System.out.println("flag is:" + flag + " t1 wait");
while (!flag)
object.wait();
System.out.println("flag is:" + flag + " t1 continue");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
t1.start();
Thread.sleep(2000);
synchronized (object) {
System.out.println("flag is:" + flag + " main change flag");
flag = true;
object.notify();
System.out.println("flag is:" + flag + " main notify t1");
}
}
}
t1發(fā)現(xiàn)flag==false，于是調(diào)用wait等待flag變?yōu)閠rue，主線程修改flag為true，調(diào)用notify喚醒t1，這就完成了一次簡單的線程間通信(同步)。
Object.wait 原理
Object.wait 源碼在之前的Java Synchronized 重量級鎖原理深入剖析下(同步篇)已經(jīng)分析過，本次著重分析它是如何響應(yīng)中斷的。
#ObjectMonitor.cpp
void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
//若是發(fā)生了中斷，則拋出中斷異常
if (interruptible && Thread::is_interrupted(Self, true) && !HAS_PENDING_EXCEPTION) {
...
THROW(vmSymbols::java_lang_InterruptedException());
return ;
}
...
//釋放鎖
exit (true, Self) ;
{
{
if (interruptible && (Thread::is_interrupted(THREAD, false) || HAS_PENDING_EXCEPTION)) {
//中斷
} else
if (node._notified == 0) {
//掛起線程，阻塞于此
if (millis <= 0) {
Self->_ParkEvent->park () ;
} else {
ret = Self->_ParkEvent->park (millis) ;
}
}
}
}
//喚醒之后，先獲取鎖
if (v == ObjectWaiter::TS_RUN) {
...
} else {
//重新獲取鎖
ReenterI (Self, &node) ;
node.wait_reenter_end(this);
}
if (!WasNotified) {
if (interruptible && Thread::is_interrupted(Self, true) && !HAS_PENDING_EXCEPTION) {
//喚醒后，發(fā)現(xiàn)曾經(jīng)發(fā)生過中斷，于是拋出異常
THROW(vmSymbols::java_lang_InterruptedException());
}
}
}
由此可見，調(diào)用Object.wait()后：
1、線程釋放鎖。
2、線程調(diào)用ParkEvent.park(xx)-->os::Linux::safe_cond_timedwait()-->NPTL.pthread_cond_timedwait(xx) 掛起線程。
3、線程被喚醒后繼續(xù)爭搶鎖。
4、若在1、2、3 階段發(fā)生中斷，則重置中斷標記位，并拋出中斷異常。
5、Condition.await 應(yīng)用及原理
Condition.await 應(yīng)用
Condition.await 作用：
與Object.wait 作用一樣。
看看Condition.java里的定義：
void await() throws InterruptedException;
可以看出，可能會拋出中斷異常。
當然await(xx)可以設(shè)置超時時間。
boolean await(long time, TimeUnit unit) throws InterruptedException;
超時時間單位可選毫秒/納秒等。
看看Demo：
public class TestThread {
public static Lock myLock = new ReentrantLock();
public static Condition condition = myLock.newCondition();
public static volatile boolean flag = false;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
myLock.lock();
try {
System.out.println("flag is:" + flag + " t1 await");
while (!flag)
condition.await();
System.out.println("flag is:" + flag + " t1 continue");
} catch (InterruptedException e) {
} finally {
myLock.unlock();
}
}
});
t1.start();
Thread.sleep(2000);
myLock.lock();
try {
System.out.println("flag is:" + flag + " main change flag");
flag = true;
condition.signal();
System.out.println("flag is:" + flag + " main signal t1");
} catch (Exception e) {
} finally {
myLock.unlock();
}
}
}
與Object.wait Demo類似，只是Object.wait需要配合synchronized使用，而Condition.await需要配合Lock使用。
Condition.await 原理
原理請移步：Java并發(fā)之 AQS 深入解析(下)
6、總結(jié)
Thread.sleep/Thread.join/Thread.yield 和鎖沒有任何關(guān)系，而Object.wait調(diào)用前需要先獲取synchronized鎖，Condition.await調(diào)用前需要先獲取Lock鎖，因此它們和鎖有關(guān)系。
之所以容易把它們幾個弄混，是因為表面上看調(diào)用這些方法后都會使得線程阻塞。除去Thread.yield外，其它方法阻塞線程都是通過調(diào)用底層的NPTL對應(yīng)的函數(shù)。
最后，用一張圖總結(jié)本篇分析的內(nèi)容：
此處需要說明的是：
我們關(guān)注與鎖有無關(guān)系是基于外部上鎖，臨界區(qū)執(zhí)行Thread.sleep/Thread.yield/Thread.join/Object.wait/Condition.await 等方法是否與鎖有關(guān)系。因此Thread.join 是與鎖沒有關(guān)系，只是內(nèi)部使用了synchronized+Object.wait。
下篇分析ReentrantLock、ReentrantReadWriteLock 原理及其應(yīng)用。
本文基于jdk1.8。
