前言

線程并發(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 異常勃刨。當(dāng)然也可以通過:

 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();
        }
    }

上述代碼標(biāo)注的(1)/(2)/(3)股淡，分別傳入負(fù)數(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) {
    //如果傳入的時間為負(fù)數(shù)叁巨，則拋出IllegalArgumentException 異常
    THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
  }

  //如果發(fā)生中斷，則將中斷標(biāo)記位置為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)衙猪，傳參是負(fù)數(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ā)生中斷，則拋出中斷異常瞒御，并將中斷標(biāo)記位置為false父叙。

2、Thread.yield 應(yīng)用及原理

Thread.yield 應(yīng)用

Thread.yield 作用：

調(diào)用Thread.yield后肴裙，線程讓出CPU趾唱，CPU調(diào)度優(yōu)先級比當(dāng)前線程更高或者優(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))
            //沒有無休止地輪訓(xùn)，而是yield一會
            Thread.yield();
        return false;
    }

比如：線程A往同步隊列里放節(jié)點烤惊，線程B查詢乔煞，因為A、B并不是嚴(yán)格意義上的同步關(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空骚，直接返回
  //默認(rèn)是支持的
  if (os::dont_yield()) return;
  //ConvertYieldToSleep 默認(rèn)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)用者線程阻塞等待直到目標(biāo)線程停止運行后再返回。
可以用來做線程間簡單同步肋坚，比如A線程(調(diào)用者線程)等待B(目標(biāo)線程)執(zhí)行結(jié)束后再做其它動作乡括。

在Thread.java 里的定義：

public final void join() throws InterruptedException(){...}

當(dāng)然也可以設(shè)置超時時間，若是超時時間耗盡后智厌，目標(biāo)線程還沒執(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

可以看出該方法可能會拋出中斷異常翘狱。
當(dāng)然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ā)生中斷挣惰，則重置中斷標(biāo)記位，并拋出中斷異常殴边。

5憎茂、Condition.await 應(yīng)用及原理

Condition.await 應(yīng)用

Condition.await 作用：
與Object.wait 作用一樣。

看看Condition.java里的定義：

void await() throws InterruptedException;

可以看出锤岸，可能會拋出中斷異常竖幔。
當(dāng)然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)容：

image.png

此處需要說明的是：

我們關(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采缚。

您若喜歡，請點贊挠他、關(guān)注扳抽，您的鼓勵是我前進的動力

持續(xù)更新中，和我一起步步為營系統(tǒng)殖侵、深入學(xué)習(xí)Java/Android