sleep()、wait()、yield()、join()方法 解析
一 java多執行緒機制
JAVA多執行緒機制有兩種實現方式:
第一種: 繼承Thread類, 實現run()方法.
第二種: 實現Runnable介面.
例項程式碼:
第一種:
public class OntThread extends Thread {
public static void main(String[] args) {
OntThread tsub = new OntThread();
tsub.start();
try {
Thread.sleep(1000);
System.out.println("main");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void run() {
System.out.println("sub");
}
}
第二種:
public class ThreadRunnable implements Runnable {
public void run() {
System.out.println("sub");
}
}
public class TwoThread {
public static void main(String[] args) {
ThreadRunnable sub = new ThreadRunnable();
Thread tsub = new Thread(sub);
tsub.start();
try {
Thread.sleep(1000);
System.out.println("main");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
兩種方式的執行結果一樣: 即: sub main
注:這裡的Thread.sleep(1000);是讓主執行緒停止1000納秒. 這時子執行緒正在工作中.
二 Thread 類的常用函式及功能:
1 sleep() 使當前執行緒進入停滯狀態，所以執行sleep()的執行緒在指定的時間內肯定不會執行, 同時sleep函式不會釋放鎖資源.
sleep可使優先順序低的執行緒得到執行的機會，當然也可以讓同優先順序和高優先順序的執行緒有執行的機會
2 yield() 只是使當前執行緒重新回到可執行狀態，所以執行yield()執行緒有可能在進入到可執行狀態後馬上又被執行. 只能使同優先順序的執行緒有執行的機會。同樣, yield()也不會釋放鎖資源.
sleep和yield的區別在於, sleep可以使優先順序低的執行緒得到執行的機會, 而yield只能使同優先順序的執行緒有執行的機會.
程式碼示例:
public class ThreadYieldOne implements Runnable {
public String name;
public void run() {
for (int i = 0; i < 10; i++) {
Thread.yield(); // (2) Thread.sleep(100);
System.out.println(name + " :" + i);
}
}
}
public static void main(String[] args) {
ThreadYieldOne one = new ThreadYieldOne();
ThreadYieldOne two = new ThreadYieldOne();
one.name = "one";
two.name = "two";
Thread t1 = new Thread(one);
Thread t2 = new Thread(two);
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY); // (1) t2.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.start();
}
程式碼執行結果:
one :0 one :1 one :2 one :3 one :4 one :5 one :6 one :7 one :8 one :9
two :0 two :1 two :2 two :3 two :4 two :5 two :6 two :7 two :8 two :9
注: (1) 處 如果放開註釋掉t2.setPriority(Thread.MIN_PRIORITY); , 則執行結果將會改變: 如下: one和two 交替列印.
one :0 one :1 one :2 one :two :0 two :1 two :2 two :3 one :4 one :5 one :3 two :4 two :5 two :6 two :6 one :7 one :8 one :9
7 two :8 two :9
(2)處 如果放開並洲釋掉Thread.yield(); , 則掃行結果也是one 和two 交替列印, 並且, 它不受(1)處的影響.
3 stop() 些方法可以中止一個正在執行的執行緒, 但這樣的方法並不安全. 強列建議不要使用此函式來中斷執行緒.
注: stop方法是立即停止當前執行緒, 這樣停止的後果是導致stop後的語句無法執行, 有可能資源未釋放. 列或者在同步塊中呼叫此方法會導致同步資料會不完整. 所以需禁用此方法. 由於stop方法的特釋性, 將不給出示範程式碼.
4 interrupt() 一個執行緒意味著在該執行緒完成任務之前停止其正在進行的一切，有效地中止其當前的操作。執行緒是死亡、還是等待新的任務或是繼續執行至下一步，就取決於這個程式.
Thread.interrupt()方法不會中斷一個正在執行的執行緒。這一方法實際上完成的是，線上程受到阻塞時丟擲一箇中斷訊號，這樣執行緒就得以退出阻塞的狀態。更確切的說，如果執行緒被Object.wait, Thread.join和Thread.sleep三種方法之一阻塞，那麼，它將接收到一箇中斷異常（InterruptedException），從而提早地終結被阻塞狀態,
兩個解釋為什麼會相沖突呢, 一個解釋是可以中斷一個執行緒. 一個解釋說不會中斷一個正在執行的執行緒. 仔細看會發現其中的奧秒. interrupt方法不會中斷一個正在執行的執行緒.就是指執行緒如果正在執行的過程中, 去呼叫此方法是沒有任何反應的. 為什麼呢, 因為這個方法只是提供給 被阻塞的執行緒, 即當執行緒呼叫了.Object.wait, Thread.join, Thread.sleep三種方法之一的時候, 再呼叫interrupt方法, 才可以中斷剛才的阻塞而繼續去執行執行緒.
程式碼說明一切.
情況1. 不會中斷執行緒.
public class guoInterrupt extends Thread {
public boolean stop = false;
public static void main(String[] args) throws InterruptedException {
guoInterrupt t1 = new guoInterrupt();
System.out.println("app is starting");
t1.start();
Thread.sleep(3000);
System.out.println("Interrupting t1....");
t1.interrupt();
Thread.sleep(3000);
System.out.println("app is end");
t1.stop = true;
System.exit(0);
}
public void run() {
while(!this.stop) {
System.out.println("t1 running...........");
l ong time = System.currentTimeMillis();
while ( (System.currentTimeMillis()-time < 1000) && (!stop) ) {};
}
System.out.println("t1 is end");
}
}
執行結果:
app is starting
t1 running...........
t1 running...........
t1 running...........
t1 running...........
Interrupting t1....
t1 running...........
t1 running...........
t1 running...........
app is end
t1 is end
結果說明. 當呼叫了interrupt時, t1執行緒仍在執行, 並沒有中斷執行緒. 直到main掃行結束後, 改t1的stop值時 t1執行緒才執行結束.
情況2: interrupt中斷執行緒.
public class guoInterrupt extends Thread {
public boolean stop = false;
public static void main(String[] args) throws InterruptedException {
guoInterrupt t1 = new guoInterrupt();
System.out.println("app is starting");
t1.start();
Thread.sleep(3000);
System.out.println("Interrupting t1....");
t1.stop = true;
t1.interrupt();
Thread.sleep(3000);
System.out.println("app is end");
System.exit(0);
}
public void run() {
while(!this.stop) {
System.out.println("t1 running...........");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
System.out.println("t1 is Interrupting......");
}
}
System.out.println("t1 is end");
}
}
執行結果:
app is starting
t1 running...........
t1 running...........
t1 running...........
Interrupting t1....
t1 is Interrupting......
t1 is end
app is end
結果說明: 當執行了 t1.interrupt();方法時, 執行緒立即產生了一個.InterruptedException 異常.
5 join() 當join(0)時等待一個執行緒直到它死亡, 當join(1000)時等待一個執行緒1000納秒,後回到主執行緒繼續執行.
程式碼示例:
public static void main(String[] args) {
ThreadJoin t = new ThreadJoin();
try {
t.start();
Thread.sleep(1000);
System.out.println("main join start");
t.join(0); // (1)
System.out.println("main join end");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public class ThreadJoin extends Thread {
public void run() {
System.out.println("join start");
try {
Thread.sleep(9000);
for (int i = 0; i < 5; i++) {
System.out.println("sub thread:" + i);
}
} catch (InterruptedException e) {
}
System.out.println("join end");
}
}
說明: (1) 為t.join(0)時 等待t執行緒執行完之後回到main函式的主執行緒繼續處理.
執行結果
join start
main join start
sub thread:0
sub thread:1
sub thread:2
sub thread:3
sub thread:4
join end
main join end
(1) 處改為t.join(1000)時, main函式的主執行緒等待t經程1000納秒後繼續執行
執行結果:
join start
main join start
main join end
sub thread:0
sub thread:1
sub thread:2
sub thread:3
sub thread:4
join end
注: join函式為執行緒安全函式, 即同步函式. 也就是說上面的例子, 當ThreadJoin類的run用synchronized鎖住時, t.join方法將得不到鎖資源而等待更長的時間.
程式碼示例:
public class guoJoin {
public static void main(String[] args) {
ThreadJoin t = new ThreadJoin();
try {
t.start();
Thread.sleep(1000);
System.out.println("main join start");
t.join(1000);
System.out.println("main join end");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class ThreadJoin extends Thread {
public void run() {
synchronized (this) {
System.out.println("join start");
try {
Thread.sleep(9000);
for (int i = 0; i < 5; i++) {
System.out.println("sub thread:" + i);
}
} catch (InterruptedException e) {
}
System.out.println("join end");
}
}
}
執行結果
join start
main join start
sub thread:0
sub thread:1
sub thread:2
sub thread:3
sub thread:4
join end
main join end
結果說明: 當main函式中呼叫t.join();時, 由於 t.run()方法對t執行緒做了同步處理, 即得到了鎖資源, 而此時t.join()方法呼叫時只能等待t.run()方法執行完成之後, 釋放了鎖資源之後. t.join函式才可以繼續等待. 即main實際等待了 9000 + 1000納秒.
6 suspend(), resume() 這兩個是JDK的過期方法. suspend()函式，可使執行緒進入停滯狀態. 通過suspend()使執行緒進入停滯狀態後，除非收到resume()訊息，否則該執行緒不會變回可執行狀態
示範程式碼
public class guoSuspend {
public static void main(String[] args) {
ThreadSuspend t = new ThreadSuspend();
t.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
}
System.out.println("main suspend start");
t.suspend();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
}
t.resume();
System.out.println("main resume end ");
}
}
public class ThreadSuspend extends Thread {
public void run() {
for (int i = 0; i < 6; i++) {
System.out.println("ThreadSuspend:" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
}
}
執行結果:
ThreadSuspend:0
main suspend start
main resume end
ThreadSuspend:1
ThreadSuspend:2
ThreadSuspend:3
ThreadSuspend:4
ThreadSuspend:5
三 多執行緒的同步
synchronized, wait, notify
執行緒的同步需要依靠上面兩個函式和一個同步塊實現.
同步, 即兩個執行緒為了一件事情協同合作執行. 例如, 緩衝區的讀寫操作. 在實際應用中, 例如:/
有一個緩衝區, 由兩個執行緒進行操作, 一個寫執行緒, 一個讀執行緒. 寫執行緒完成對緩衝區的寫入, 讀執行緒完成對執行緒的讀取, 只有當緩衝區寫入資料時, 讀執行緒才可以讀取, 同樣. 只有當緣衝區的資料讀出時, 寫執行緒才可以向緣衝區寫入資料.
程式碼示例:
public class ThreadWrite extends Thread {
public StringBuffer buffer;
public ThreadWrite(StringBuffer buffer) {
this.buffer = buffer;
}
public void run() {
synchronized (this.buffer) {
for (int i = 0; i < 5; i++) {
if (!"".equals(this.buffer.toString())) {
try {
buffer.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Write start");
this.buffer.append("123");
this.buffer.notify();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("Write end");
}
}
}
}
public class ThreadRead extends Thread {
public StringBuffer buffer;
public ThreadRead(StringBuffer buffer) {
this.buffer = buffer;
}
public void run() {
synchronized (buffer) {
for (int i = 0; i < 5; i++) {
if ("".equals(this.buffer.toString().trim())) {
try {
buffer.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("read start");
System.out.println(this.buffer.toString());
buffer.delete(0, buffer.toString().length());
buffer.notify();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
}
System.out.println("read end");
}
}
}
}
public class GuoSynchronized {
public static void main(String[] args) {
StringBuffer bufer = new StringBuffer("");
ThreadWrite write = new ThreadWrite(bufer);
ThreadRead read = new ThreadRead(bufer);
read.start();
write.start();
}
}
執行結果:
Write start
Write end
read start
123
read end
Write start
Write end
read start
123
read end
Write start
Write end
read start
123
read end
Write start
Write end
read start
123
read end
Write start
Write end
read start
123
read end
結果說明: 這個結果不管執行多少次, 都會是相同的結果, 即多執行緒同步的特點.
注: synchronized 關鍵字的同步, 在兩個執行緒之間必須是同一個物件, 即 對同一個物件進行同步訪問.
四 死鎖
為什麼會產生死鎖? 在多執行緒環境裡, 產生死鎖的原因是由於幾個執行緒同時共用一個同步資源. 這是產生死鎖的前提,
產生死鎖的原因, 所有執行緒都在等待共享資源的釋放.
例如:
執行緒1寫緩衝區時, 緩衝區已滿 , 執行緒1等待.
執行緒2讀緩衝區, 當緩衝區讀完時, 喚醒共享資源鎖上的1個執行緒, 並且執行緒2再去讀取緩衝區時, 由於緩衝區被讀完, 執行緒2等持.
剛剛執行緒2喚醒了一個共享資源鎖上的1個執行緒, 而共享資源鎖上的執行緒可能有好幾個, 有可能是讀執行緒, 有可能是寫執行緒. 假如此時喚醒的正好是讀執行緒3, 那麼執行緒3去讀取緩衝區, 這時的緩衝區已經執行緒2讀完了, 執行緒3需要等持緩衝區被寫入資料時才可以讀取緩衝區, 即此時執行緒3也被阻塞了. 即等待.
此時, 執行緒1等待, 執行緒2由於讀完了, 也等待, 執行緒3的情況和2一樣, 也等待. 其它共享資源上的執行緒也都在等待, 死鎖即發生了.
看程式碼示例:
public class GuoSynchronized {
public static void main(String[] args) {
StringBuffer bufer = new StringBuffer("");
ThreadWrite write1 = new ThreadWrite(bufer,"w1");
ThreadWrite write2 = new ThreadWrite(bufer,"w2");
ThreadWrite write3 = new ThreadWrite(bufer,"w3");
ThreadRead read1 = new ThreadRead(bufer,"r1");
ThreadRead read2 = new ThreadRead(bufer,"r2");
ThreadRead read3 = new ThreadRead(bufer,"r3");
read1.start();
read2.start();
read3.start();
write1.start();
write2.start();
write3.start();
}
}
public class ThreadRead extends Thread {
public StringBuffer buffer;
public ThreadRead(StringBuffer buffer, String name) {
super(name);
this.buffer = buffer;
}
public void run() {
synchronized (buffer) {
for (int i = 0; i < 5; i++) {
while ("".equals(this.buffer.toString().trim())) {
try {
buffer.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("read " + Thread.currentThread().getName() + " start");
System.out.println(this.buffer.toString());
buffer.delete(0, buffer.toString().length());
buffer.notify();
System.out.println("read " + Thread.currentThread().getName() + " end");
}
}
}
}
public class ThreadWrite extends Thread {
public StringBuffer buffer;
public ThreadWrite(StringBuffer buffer, String name) {
super(name);
this.buffer = buffer;
}
public void run() {
synchronized (this.buffer) {
for (int i = 0; i < 5; i++) {
while (!"".equals(this.buffer.toString())) {
try {
buffer.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Write " + Thread.currentThread().getName() + " start");
this.buffer.append("123");
System.out.println("123");
this.buffer.notify();
System.out.println("Write " + Thread.currentThread().getName() + " end");
}
}
}
}
執行結果很有可能被死鎖住了.
要改變這一狀況, 可將, 兩個執行緒類的this.buffer.notify();函式改為this.buffer.notifyAll();即可解除這種死鎖.
上面由於存在程式碼示例，顯得有些冗長，下面簡單總結下：
1.sleep()方法
在指定時間內讓當前正在執行的執行緒暫停執行，但不會釋放“鎖標誌”。不推薦使用。
sleep()使當前執行緒進入阻塞狀態，在指定時間內不會執行。
2.wait()方法
在其他執行緒呼叫物件的notify或notifyAll方法前，導致當前執行緒等待。執行緒會釋放掉它所佔有的“鎖標誌”，從而使別的執行緒有機會搶佔該鎖。
當前執行緒必須擁有當前物件鎖。如果當前執行緒不是此鎖的擁有者，會丟擲IllegalMonitorStateException異常。
喚醒當前物件鎖的等待執行緒使用notify或notifyAll方法，也必須擁有相同的物件鎖，否則也會丟擲IllegalMonitorStateException異常。
waite()和notify()必須在synchronized函式或synchronized block中進行呼叫。如果在non-synchronized函式或non-synchronized block中進行呼叫，雖然能編譯通 過，但在執行時會發生IllegalMonitorStateException的異常。
3.yield方法
暫停當前正在執行的執行緒物件。
yield()只是使當前執行緒重新回到可執行狀態，所以執行yield()的執行緒有可能在進入到可執行狀態後馬上又被執行。
yield()只能使同優先順序或更高優先順序的執行緒有執行的機會。
4.join方法
等待該執行緒終止。
等待呼叫join方法的執行緒結束，再繼續執行。如：t.join();//主要用於等待t執行緒執行結束，若無此句，main則會執行完畢，導致結果不可預測。
相關推薦
sleep()，wait()，yield()和join()方法的區別
sleep() sleep()方法需要指定等待的時間，它可以讓當前正在執行的執行緒在指定的時間內暫停執行，進入阻塞狀態，該方法既可以讓其他同優先順序或者高優先順序的執行緒得到執行的機會，也可以讓低優先順序的執行緒得到執行機會。但是sleep()方法不會釋放
執行緒：sleep()、wait()、yield()和join()方法
1.sleep()和wait() 這兩個方法都可以讓呼叫它的執行緒沉睡(sleep)/停止執行(wait)指定的時間，到了這個時間，執行緒就會自動醒來，變為可執行狀態（RUNNABLE）。 public static native vo
sleep()、wait()、yield()、join()方法 解析
一 java多執行緒機制 JAVA多執行緒機制有兩種實現方式: 第一種: 繼承Thread類, 實現run()方法. 第二種: 實現Runnable介面. 例項程式碼: 第一種: public class OntT
Java執行緒休眠方法sleep、執行緒讓步yield和join方法
執行緒休眠(sleep方法） 執行緒休眠：讓執行緒暫緩執行，等到預計時間之後再恢復執行。 執行緒休眠會交出cpu,讓cpu去執行其他任務，但是不會釋放鎖。 比如：當前執行緒sleep休眠了，但是如果此執行緒在休眠前持有某個物件的鎖，那就算它休眠了其他執行緒也不能獲取到這個物件的鎖。
Java 中Thread的sleep、join方法解析
開始 system sleep main gen 解析 等待時間 calling trace 1.Thread中sleep方法作用是使當前線程等待，其他線程開始執行，如果有線程鎖，sleep不會讓出鎖 沒有加鎖代碼如下： public class Synchronized
java多執行緒中的sleep（）、wait（）、notify（）和物件鎖的關係
1、sleep（）不釋放物件鎖。 2、wait（）釋放物件鎖。 3、notify（）不釋放物件鎖。 （1）、notify釋放鎖嗎？不要誤導別人。notifty()只是喚醒此物件監視器上等待的單個執行緒，直到當前執行緒釋放此物件上的鎖，才有可能繼續執行被喚醒的執行緒。 （2）
Java執行緒中yield與join方法的區別
長期以來，多執行緒問題頗為受到面試官的青睞。雖然我個人認為我們當中很少有人能真正獲得機會開發複雜的多執行緒應用(在過去的七年中，我得到了一個機會)，但是理解多執行緒對增加你的信心很有用。之前，我討論了一個wait()和sleep()方法區別的問題，這一次，我將會討
多執行緒中yield()和join()方法的對比
1.yield():呼叫此方法的執行緒，釋放當前cpu的執行權class SubTread extends Thread{ @Override public void run() { for(int i=1;i<=100;i++){ System.out.
執行緒中的一些常用方法的用法 join（）、yield()、sleep（）、wait()、notify（）、notifyAll（）
1.執行緒休眠sleep();:執行緒有優先順序，但是我們可以用此方法人為的改變它們的優先順序，讓執行緒暫停，它其他執行緒獲得分配空間。 用法：Thread.sleep（2000）;//休眠兩秒 2.執行緒讓步yield();就是讓出自己的分配空間給其他執行
Java執行緒中sleep()、wait()和notify()和notifyAll()、yield()、join()等方法的用法和區別
Java執行緒中sleep()、wait()和notify()和notifyAll()、suspend和resume()、yield()、join()、interrupt()的用法和區別從作業系統的角度講，os會維護一個ready queue（就緒的執行緒佇列）。並且在某一
多執行緒常用操作方法（sleep、yield、join）
執行緒的命名與取得 執行緒的命名： 通過構造方法在建立執行緒時設定執行緒名稱 直接繼承Thread類： public Thread (String name); Runable或者Callable介面實現多執行緒： public Thread (Run
sleep、yield、wait、join的區別
1.sleep：Thread類的方法，必須帶一個時間引數。會讓當前執行緒休眠進入阻塞狀態並釋放CPU，提供其他執行緒執行的機會且不考慮優先順序，但如果有同步鎖則sleep不會釋放鎖即其他執行緒無法獲得同步鎖 2.yield：Thread類的方法，類似sleep但無法指定時間
關於sleep()、yield()、wait()三種讓執行緒暫停方法的區別
一、sleep（）是讓當前真正執行的執行緒暫停一段時間，並進入阻塞狀態 噹噹前執行緒呼叫sleep（）方法進入阻塞狀態後，在其睡眠狀態內，執行緒不會獲得執行的機會，即使系統沒有其他可執行路徑，處於sleep()中的執行緒也不會執行 二、yield()方法是Thread類提供
【多執行緒】——join、yield、wait、sleep的區別
join 通常由使用執行緒的程式呼叫，將大問題劃分為許多小問題，每個小問題分配一個執行緒，當所有小問題都得到處理後，再呼叫主執行緒進一步操作。 join(); Join(long mi
java中執行緒阻塞之sleep、suspend、join、wait、resume、notify方法解析（一）
java執行緒的5狀態包括create、runnable、running、blocked、dead。 create是指用new執行緒被建立，但是還沒有準備好各種資源。 runnable是指使用start啟動執行緒，這時候系統會為執行緒分配除cpu以外的所有需要的資源。 ru
Android進階——多執行緒系列之wait、notify、sleep、join、yield、synchronized關鍵字、ReentrantLock鎖
前言 多執行緒一直是初學者最困惑的地方，每次看到一篇文章，覺得很有難度，就馬上叉掉，不看了，我以前也是這樣過來的。後來，我發現這樣的態度不行，知難而退，永遠進步不了。於是，我狠下心來看完別人的部落格，儘管很難但還是咬著牙，不懂去查閱資料，到最後弄懂整個過程。雖
yield、sleep、wait、notify、join
針對 直接 並且 獲取對象 其它 join 操作系統概念 sleep 運行 Obj.wait()，與Obj.notify()必須要與synchronized(Obj)一起使用 在JAVA中，是沒有類似於PV操作、進程互斥等相關的方法的。JAVA的進程同步是通過synchr
Java多執行緒中join、yield、sleep方法詳解
在Java多執行緒程式設計中，Thread類是其中一個核心和關鍵的角色。因此，對該類中一些基礎常用方法的理解和熟練使用是開發多執行緒程式碼的基礎。本篇主要總結一下Thread中常用的一些靜態方法的含義及程式碼中的使用。 sleep方法 原始碼如下： /** * Causes the curr
Java併發程式設計之執行緒生命週期、守護執行緒、優先順序和join、sleep、yield
Java併發程式設計中，其中一個難點是對執行緒生命週期的理解，和多種執行緒控制方法、執行緒溝通方法的靈活運用。這些方法和概念之間彼此聯絡緊密，共同構成了Java併發程式設計基石之一。 Java執行緒的生命週期 Java執行緒類定義了New、Runnable、Running Man、Blocked和Dead
Thread->sleep、wait、join使用
Thread sleep、wait、join使用 這裡先介紹join,然後把兩個有關聯的sleep和wait一起介紹. join() 這個方法比較好理解,當前執行緒等待指定執行緒終止後在執行,將兩個交替執行的執行緒合併為順序執行的執行緒.比如在B執行緒