新建線程

新建線程很簡單。只要使用new 關鍵字創建一個線程對象，并且調用 start 方法啟動線程。

Thread t = new Thread(); t.start();

注意：run 方法不是用來啟動線程。如果調用 run 方法它只會作為普通方法來執行，而不會開啟線程執行。

終止線程

一般來說，線程在執行完畢后就會結束，無須手工關閉。但凡是都有例外。Thread 類提供了一個 stop 方法來終止線程。如果調用 stop 方法，就可以立即將一個線程終止。

目前 stop 方法已經過期。因為 stop 方法太過于暴力，它會把執行到一半的線程終止，此時可能會引起數據不一致問題。

舉例：對象 User 有 id、name 兩個屬性。寫線程總是把 id、name 寫成相同的值。當寫線程在寫對象時，讀線程由于無法獲得鎖，因此必須等待，所以讀線程是看不見一個寫了一半的對象。此時，寫線程寫完id后，很不辛被 stop，此時對象 u 的 id 為1，而 name 任然為0，出于不一致狀態。而被終止的寫線程簡單地講鎖釋放，度線程獲取到鎖后，讀取數據，于是讀到了 id=1 而 name=0 。

public class StopThreadTest {public static User u = new User();public static class User {private int id;private String name;public User() {this.id = 0;this.name = "0";}public User(int id, String name) {this.id = id;this.name = name;}public void setId(int id) {this.id = id;}public void setName(String name) {this.name = name;}public int getId() {return id;}public String getName() {return name;}@Overridepublic String toString() {return "User{" +"id=" + id +", name='" + name + '\'' +'}';}}public static class ChangeObjectThread extends Thread {@Overridepublic void run() {while (true) {synchronized (u) {int i = (int) (System.currentTimeMillis() / 1000);u.setId(i);try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}u.setName(String.valueOf(i));}}}}public static class ReadObjectThread extends Thread {@Overridepublic void run() {while (true) {synchronized (u) {if (u.getId() != Integer.valueOf(u.getName())) {System.out.println(u.toString());}}}}}public static void main(String[] args) {try {new ReadObjectThread().start();while (true) {ChangeObjectThread thread = new ChangeObjectThread();thread.start();Thread.sleep(150);thread.stop();}} catch (InterruptedException e) {e.printStackTrace();}} }

打印結果：

User{id=1619771639, name='1619771638'} User{id=1619771640, name='1619771639'}

那么如果優雅的停止一個線程，又不會產生數據不一致問題？可以考慮定義一個開關，通過開關去控制。

public class StopThreadTest {public static User u = new User();public static boolean stopme = true;public static class User {private int id;private String name;public User() {this.id = 0;this.name = "0";}public User(int id, String name) {this.id = id;this.name = name;}public void setId(int id) {this.id = id;}public void setName(String name) {this.name = name;}public int getId() {return id;}public String getName() {return name;}@Overridepublic String toString() {return "User{" +"id=" + id +", name='" + name + '\'' +'}';}}public static void stopMe(){stopme = false;}public static class ChangeObjectThread extends Thread {@Overridepublic void run() {while (stopme) {synchronized (u) {int i = (int) (System.currentTimeMillis() / 1000);u.setId(i);try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}u.setName(String.valueOf(i));}}}}public static class ReadObjectThread extends Thread {@Overridepublic void run() {while (true) {synchronized (u) {if (u.getId() == Integer.valueOf(u.getName())) {System.out.println(u.toString());}System.out.println(u.toString());}}}}public static void main(String[] args) {try {new ReadObjectThread().start();while (true) {ChangeObjectThread thread = new ChangeObjectThread();thread.start();Thread.sleep(150);stopMe();}} catch (InterruptedException e) {e.printStackTrace();}} }

日志打印：

User{id=1619774686, name='1619774686'} User{id=1619774686, name='1619774686'} User{id=1619774686, name='1619774686'}

線程中斷

從表面上理解，中斷就是讓目標線程停止執行的意思，實際上并非如此。

嚴格來講，線程中斷并不會是線程立即退出，而是給線程發送一個通知，告知目標線程，有人希望你退出。至于目標線程是否退出，由目標線程自己決定。

線程中斷三個方法：

// 中斷線程 public void interrupt(); // 判斷線程是否中斷 public boolean isInterrupted(); // 判斷線程是否中斷，并清楚當前中斷狀態 public static boolean interrupted();

interrupt() 方法通知目標方法中斷，也就是設置中斷標志位，中斷標志位表示當前線程已經被中斷了；isInterrupted() 判斷當前線程是否有被中斷；interrupted() 也是用來判斷當前線程是否被中斷，但同時會清除當前線程的中斷標志位狀態。

public void interruptTest1(){try {Thread t = new Thread() {@Overridepublic void run() {while (true) {Thread.yield();}}};t.start();Thread.sleep(2000);t.interrupt();} catch (InterruptedException e) {e.printStackTrace();}}

線程t 雖然進行了中斷，但是并沒有線程中斷后處理的邏輯，因此線程t 即使被中斷，但是這個中斷不會發生任何左右。

優化：線程中斷就退出while

public void interruptTest2() {try {Thread t = new Thread() {@Overridepublic void run() {while (true) {// 判斷當前線程是否被中斷 if (Thread.currentThread().isInterrupted()){System.out.println("Interrupted");break;}Thread.yield();}}};t.start();Thread.sleep(2000);t.interrupt();} catch (InterruptedException e) {e.printStackTrace();}}

等待和通知

為了支持多線程之間的協作，JDK 提供了兩個非常重要的接口線程等待 wait() 和通知 notify()。注意，這兩個方法不是在 Thread 類中，而是在 Object 類。這也意味著任何對象都能調用。

public final void wait() throws InterruptedException; public final native void notify();

當一個對象實例調用wait 方法后，當前線程就會在這個對象上等待。比如，線程A 中，調用了obj.wait() 方法，那么線程A 就會停止繼續執行，轉為等待狀態。當其他線程調用obj.notify() 方法為止結束等待狀態。此時obj 對象就儼然成為多個線程之間的有效通訊手段。

擴展

面試題：多線程之間的通訊方式？

wait()、notify()

同步 synchronized

while 輪訓

管道通信(PipedInputStream、PipedOutPutStream)

PS：清楚有這么一個東西即可，如何實現水平有限，可自行查閱。有錯請指教

wait()、notify() 工作過程：如果一個線程調用了 object.wait() 方法，那么它就會進入object 對象的等待隊列。在這個隊列中，可能會有多個線程。當調用 object.notify() 被調用時，它會從這個等待隊列中，隨機選擇一個線程，并將它喚醒。同時 Object 對象還提供了另一個方法 notifyAll() 方法，它和notify() 功能基本一致，不同的是notifyAll 會喚醒這個隊列中的所有等待的線程，而不是隨機選擇一個。

強調，調用wait() 方法必須在 snchronzied 語句中，無論是wait()、notify() 都需要先獲得鎖，當執行wait() 方法后，會釋放這個鎖。這樣做的目的是使得其他等待該鎖的線程不至于無法正常執行。

public class WaitNotifyTest {final static Object object = new Object();public static class T1 extends Thread {@Overridepublic void run() {synchronized (object) {System.out.println(System.currentTimeMillis() + ": T1 start");try {System.out.println(System.currentTimeMillis() + ": T1 wait for object");object.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(System.currentTimeMillis() + ": T1 end");}}}public static class T2 extends Thread {@Overridepublic void run() {synchronized (object) {System.out.println(System.currentTimeMillis() + ": T2 start ! notify one thread");object.notify();System.out.println(System.currentTimeMillis() + ": T2 end");try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}}}public static void main(String[] args) {T1 t1 = new T1();T2 t2 = new T2();t1.start();t2.start();}}

如上，兩個線程 t1、t2。t1 執行 object.wait() 方法前，獲取object 對象鎖。因此，在執行 object.wait() 是，它是持有 object 鎖，wait() 執行后，t1 會進入等待，并釋放 object 的鎖。t2 在執行 notify() 之前也會先獲取 object 的對象鎖。t1 在得到 notify() 通知后，還是會先嘗試重新獲取 object 鎖。上述運行日志打印：

1620273470618: T1 start 1620273470618: T1 wait for object 1620273470618: T2 start ! notify one thread 1620273470618: T2 end 1620273472620: T1 end

掛起和繼續執行

掛起suspend 和繼續執行resume 是一對相反的操作，被掛起suspend 的線程，必須要等到繼續執行resume 操作后，才能繼續執行。目前 suspend()、resume() 已經過時，不推薦使用。

使用 suspend() 掛起線程會導致線程被暫停，同時并不會釋放任何鎖資源。此時，其他線程想要訪問被它暫用的鎖時，都會導致無法正常繼續執行。直到對應的線程進行了resume() 操作，被掛起的線程才能繼續，從而其他阻塞的線程才可以繼續執行。嚴重的情況是：它暫用的鎖不會被釋放，因此可能會導致整個系統工作不正常。而且，對于被掛起的線程，從它的線程狀態上看，居然還是Runnable ，嚴重影響對系統當前狀態的判斷。

public class SuspengResumeTest {public static Object object = new Object();static ChangeObjectThread t1 = new ChangeObjectThread("t1");static ChangeObjectThread t2 = new ChangeObjectThread("t2");public static class ChangeObjectThread extends Thread{public ChangeObjectThread(String name) {super.setName(name);}@Overridepublic void run() {synchronized (object) {System.out.println(System.currentTimeMillis() + " in "+ getName());Thread.currentThread().suspend();System.out.println(System.currentTimeMillis() + " in "+ getName());}}}public static void main(String[] args) {try {t1.start();Thread.sleep(1000);t2.start();t1.resume();t2.resume();t1.join();t2.join();} catch (InterruptedException e) {e.printStackTrace();}} }

結果打印：

1620285481858 in t1 1620285482859 in t1 1620285482859 in t2

通過日志發現，他們都獲取到了鎖。但是線程不會退出，而是是會掛起。雖然主函數已經調用了 resume() ，但是由于事件先后順序的緣故，導致 t2 線程被永遠掛起，并且占用了對象鎖。

優化 suspend()、resume()：

public class SuspengResumeTest2 {public static Object object = new Object();public static class ChangeObjectThread extends Thread {volatile boolean suspendme = false;public void suspendsMe() {suspendme = true;}public void resumeMe() {suspendme = false;synchronized (this) {notify();}}@Overridepublic void run() {while (true) {synchronized (this) {while (suspendme) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}}synchronized (object) {System.out.println("in ChangeObjectThread");}Thread.yield();}}}public static class ReadObjectThread extends Thread{@Overridepublic void run() {while (true) {synchronized (object) {System.out.println("in ReadObjectThread");}Thread.yield();}}}public static void main(String[] args) {try {ChangeObjectThread t1 = new ChangeObjectThread();ReadObjectThread t2 = new ReadObjectThread();t1.start();t2.start();Thread.sleep(1000);t1.suspendsMe();System.out.println("suspend t1 2 sec");Thread.sleep(2000);System.out.println("resume t1");t1.resumeMe();} catch (InterruptedException e) {e.printStackTrace();}}}

等待線程結束join 和謙讓yield

很多時候，一個線程的執行很可能需要依賴于另外一個或者多個線程執行完畢之后才能繼續執行。比如，日常工作需要產品先出需求文檔，然后召開需求評審，緊接著進行軟件開發。JDK 提供了 join() 來實現這個功能。

public final void join() throws InterruptedException; public final synchronized void join(long millis) throws InterruptedException;

第一個 join() 表示無限等待，他會一致阻塞當前線程，直到目標線程執行完畢。

第二個 join(long) 表示最大等待時間，如果超過給定時間目標線程還在執行，當前線程也會因為“等不及了”，而繼續往下執行。

public class JoinTest {public volatile static int num = 1;public static class JoinThread extends Thread {@Overridepublic void run() {for (; num < 100000000; num++) ;}}public static void main(String[] args) {try {JoinThread joinThread = new JoinThread();joinThread.start();joinThread.join();System.out.println("num :" + num);} catch (InterruptedException e) {e.printStackTrace();}}}

結果打印：

num :100000000

如果把 joinThread.join(); 注釋掉，查看日志 num :1 。

主函數在等待 joinThread 線程執行完畢再繼續執行，此時 num 為 100000000。

擴展

join() 的本質是讓調用線程 wait() 在當前線程對象實例上。源碼：

public final void join() throws InterruptedException {join(0); } public final synchronized void join(long millis) throws InterruptedException {long base = System.currentTimeMillis();long now = 0;if (millis < 0) {throw new IllegalArgumentException("timeout value is negative");}if (millis == 0) {while (isAlive()) {wait(0);}} else {while (isAlive()) {long delay = millis - now;if (delay <= 0) {break;}wait(delay);now = System.currentTimeMillis() - base;}}}

可以看到，它讓調用線程在當前線程對象上進行等待。當線程執行完成后，被等待的線程會在退出前調用 notifyAll() 通知所有的等待線程繼續執行。因此，不建議直接在 Thread 對象實例上使用類似于 wait()和notify() 等方法，因為這有可能影響系統API的工作。

Thread 類中的另一個方法 yield()，定義：

public static native void yield();

靜態方法，一大執行，它會使得當前線程讓出CPU。但是要注意，讓出CPU 并不表示當前線程不執行。當前線程在讓出CPU 后，還會進行CPU 資源的爭奪，能夠再次被分配就不一定了。因此，Thread.yield() 的調用就好像再說，我已經完成了一些最重要的工作了，可以休息一下了，可以給其他線程一些工作機會！

總結

以上是生活随笔為你收集整理的《Java 高并发》04 线程的基本操作的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。