Java多线程详解[狂神说Java]
生活随笔
收集整理的這篇文章主要介紹了
Java多线程详解[狂神说Java]
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
文章目錄
- 多線程01： 線程的生命周期
- 多線程02：創建線程：繼承Thread類
- 案例：下載圖片
- 多線程03： 創建線程：實現Runnable接口
- 案例：多線程操作同一資源對象
- 案例：龜兔賽跑
- 多線程04：創建線程：實現Callable接口
- 多線程05：lambda表達式
- 多線程06：線程狀態
- 多線程07：線程的優先級
- 多線程08：守護線程(daemon)
- 多線程09：線程同步
- 多線程10：死鎖
- 多線程11：線程協作
- 參考資料
Java支持多線程編程。線程的概念是什么呢？一條線程指的是進程中一個單一順序的控制流，一個進程中可以并發多個線程，每條線程并行執行不同的任務。
那什么是進程呢？ 進程是操作系統分配資源的最小單位，一個進程包括由操作系統分配的內存空間、一個或多個線程。注意，線程不能單獨存在，它必須是進程的一部分。一個進程一直運行，直到所有的非守護線程都結束運行后才能結束。注：守護線程（Daemon，發音：英 [?di?m?n] ）
多線程能滿足程序員編寫高效率的程序來達到充分利用cpu的目的。
多線程是多任務的一種特別形式，但多線程使用了更小的資源開銷。
多線程01： 線程的生命周期
線程是一個動態執行的過程，它有一個從產生到死亡的過程。
下圖顯示了一個線程完整的生命周期：
來源：菜鳥教程
線程的五大狀態
-
新建狀態
使用new關鍵字和Thread類或其子類建立一個線程對象后，該線程對象就處于新建狀態。它保持這個狀態直到程序start()這個線程。 -
就緒狀態
當線程對象調用了start()方法之后，該線程就進入了就緒狀態。就緒狀態的線程處于就緒隊列中，要等待JVM里線程調度器的調度。 -
運行狀態
如果就緒狀態的線程獲取CPU的資源，就可以執行run()方法，此時線程便處于運行狀態。處于運行狀態的線程有多種變化方式，它可以變為阻塞狀態、就緒狀態和死亡狀態。 -
阻塞狀態
如果一個線程執行了sleep（睡眠）、suspend（掛起）等方法，失去所占有的資源后，該線程就從運行狀態轉為阻塞狀態。在睡眠時間已到或獲得設備資源后可以重新進入就緒狀態。可以分為三種：
1 . 等待阻塞：運行狀態下的線程執行wait（）方法，使線程進入到等待隊列。
2 . 同步阻塞：線程在獲得synchronized同步鎖失敗（因為同步鎖被其他線程占用）。
3 . 其他阻塞：通過調用線程的sleep() 或join()發出I/O請求時，線程就會進入阻塞狀態。當sleep()狀態超時， 或join()等待線程終止或超時，或者I/O處理完畢，線程重新轉入就緒狀態。 -
死亡狀態
一個運行狀態的線程 完成任務或其他終止條件發生時，該線程就切換到終止狀態。
多線程02：創建線程：繼承Thread類
Java提供了三種創建線程的方法：
輔助幫助文檔：Class Thread
來源：Java Platform SE 8
Thread
三個步驟：1.自定義線程類Thread類；2.重寫run()方法，編寫線程結構體；3.創建線程對象，調用start()方法啟動線程。
線程不一定立即執行，CPU安排調度。
package lishizheng.demo01;//創建線程方式1：繼承Thread類，重寫run方法，調用start開啟線程 public class TestThread1 extends Thread {@Overridepublic void run() {//run方法線程體for (int i = 0; i < 20; i++) {System.out.println("我在看代碼：" + i);}}public static void main(String[] args) {//main線程，主線程//創建一個線程對象TestThread1 testThread1 = new TestThread1();//調用start方法開啟線程testThread1.start();for (int i = 0; i < 1000; i++) {System.out.println("我在學習多線程： " + i);}} }案例：下載圖片
首先下載名為commons-io的jar包：Download Apache Commons IO
解壓之后如下圖：
復制上圖中的jar包，在IDEA項目中新建文件夾lib，然后選中它，然后Ctrl+V，將jar包導入項目。
導入后，右擊lib文件夾，選擇Add As Library
彈出如下界面：點擊OK即可。
代碼如下：
package lishizheng.demo01;import org.apache.commons.io.FileUtils;import java.io.File; import java.io.IOException; import java.net.URL;//練習Thread，實現多線程下載圖片 public class TestThread2 extends Thread {private String url; //網絡圖片地址private String name; //保存的文件名public TestThread2(String url, String name){this.url = url;this.name = name;}//下載圖片線程的執行體@Overridepublic void run() {WebDownLoader webDownLoader = new WebDownLoader();webDownLoader.downloader(url,name);System.out.println("已下載文件名為：" + name + "的圖片");}public static void main(String[] args) {//確保圖片ulr是正確的TestThread2 t1 = new TestThread2("https://img-blog.csdnimg.cn/20210210194321356.png","我的博客圖片01.png");TestThread2 t2 = new TestThread2("https://img-blog.csdnimg.cn/20210228094648502.png","我的博客圖片02.png");TestThread2 t3 = new TestThread2("https://img-blog.csdnimg.cn/20210303104522231.png","我的博客圖片03.png");t1.start(); //啟動線程t2.start();t3.start();} }//下載器 class WebDownLoader{//下載方法public void downloader(String url, String name){try {FileUtils.copyURLToFile(new URL(url), new File(name)); //調用FileUtils類中的copyURLToFile方法實現下載} catch (IOException e) {e.printStackTrace();System.out.println("IO異常：downloader方法出現問題");}} } /* 執行結果： 已下載文件名為：我的博客圖片01.png的圖片 已下載文件名為：我的博客圖片02.png的圖片 已下載文件名為：我的博客圖片03.png的圖片Process finished with exit code 0*/多線程03： 創建線程：實現Runnable接口
實現Runnable步驟：1.定義MyRunnable類實現Runnable接口；2.實現run()方法，編寫線程執行體；3.創建線程對象，調用start()方法啟動線程。
創建一個線程，最簡單的方法是創建一個實現 Runnable 接口的類。如下：
public class TestThread3 implements Runnable{}在創建一個實現 Runnable 接口的類之后可以在類中實例化一個線程對象:
//創建Runnable接口的實現類對象TestThread3 testThread3 = new TestThread3();//創建線程對象，通過線程對象來開啟我們的線程，代理Thread thread = new Thread(testThread3);新線程創建之后，許喲啊調用它的 start() 方法它才會運行：
thread.start();創建對象并調用start方法可以用一句代碼實現：
new Thread(testThread3).start();//等價寫法全部代碼舉例如下：
package lishizheng.demo01;//創建線程方式2：實現Runnable接口，重寫run方法，執行線程需要丟入實現Runnable接口的實現類 public class TestThread3 implements Runnable {@Overridepublic void run() {//run方法線程體for (int i = 0; i < 20; i++) {System.out.println("我在看代碼：" + i);}}public static void main(String[] args) {//創建Runnable接口的實現類對象TestThread3 testThread3 = new TestThread3();//創建線程對象，通過線程對象來開啟我們的線程，代理Thread thread = new Thread(testThread3);thread.start();//等價寫法:// new Thread(testThread3).start();for (int i = 0; i < 1000; i++) {System.out.println("我在學習多線程： " + i);}} }/* 運行代碼其中一部分：可以發現線程的執行順序是由CPU來調度的！！！并不完全按照代碼書寫的順序。 我在學習多線程： 0 我在看代碼：0 我在學習多線程： 1 我在學習多線程： 2 我在學習多線程： 3 我在學習多線程： 4 我在學習多線程： 5 我在學習多線程： 6 我在學習多線程： 7 我在學習多線程： 8 我在學習多線程： 9 我在學習多線程： 10 我在學習多線程： 11 我在學習多線程： 12 我在學習多線程： 13 我在學習多線程： 14 我在學習多線程： 15 我在看代碼：1 我在學習多線程： 16 我在看代碼：2 我在學習多線程： 17 我在看代碼：3 我在學習多線程： 18*/小結：
- 繼承Thread類
- 實現Runnable接口
案例：多線程操作同一資源對象
下面的代碼實現搶票的功能：共有10張火車票，三個人來搶。目的是學習并體會多線程對同一個資源對象操作的情況。
補充Thread.currentThread().getName()獲取線程的名字
package lishizheng.demo01;//多個線程同時操作同一個對象 //買火車票的例子//發現問題：多個線程操作同一個資源的情況下，線程不安全，數據紊亂 public class TestThread4 implements Runnable {private int ticketNums = 10;@Override//重寫run方法public void run() {while (true){if(ticketNums <= 0) break;System.out.println( Thread.currentThread().getName() + "拿到了第 " + ticketNums-- +"張票");}}public static void main(String[] args) {TestThread4 testThread4 = new TestThread4();// 一個對象，三個線程 new Thread(testThread4, "小明").start();new Thread(testThread4,"老師").start();new Thread(testThread4,"黃牛").start();} } /* 輸出結果如下： 黃牛拿到了第 10張票 老師拿到了第 8張票 小明拿到了第 9張票 老師拿到了第 6張票 黃牛拿到了第 7張票 老師拿到了第 4張票 小明拿到了第 5張票 老師拿到了第 2張票 黃牛拿到了第 3張票 小明拿到了第 1張票Process finished with exit code 0*/案例：龜兔賽跑
模擬龜兔賽跑，兩者在同一條跑道，先跑到100步者為勝利者。
用意：體會多線程競爭資源。
下面使用到下圖中的兩個方法：
來源：菜鳥教程
多線程04：創建線程：實現Callable接口
實現Callable接口的步驟：
利用Callable修改上面下載圖片案例
package lishizheng.demo02;import org.apache.commons.io.FileUtils;import java.io.File; import java.io.IOException; import java.net.URL; import java.util.concurrent.*;//線程創建3：實現Callable接口 /* * * */ public class TestCallable implements Callable<Boolean> {private String url; //網絡圖片地址private String name; //保存的文件名public TestCallable(String url, String name){this.url = url;this.name = name;}//下載圖片線程的執行體@Overridepublic Boolean call() {WebDownLoader webDownLoader = new WebDownLoader();webDownLoader.downloader(url,name);System.out.println("已下載文件名為：" + name + "的圖片");return true;}public static void main(String[] args) throws ExecutionException, InterruptedException {//確保圖片ulr是正確的TestCallable t2 = new TestCallable("https://img-blog.csdnimg.cn/20210228094648502.png","我的博客圖片02.png");TestCallable t3 = new TestCallable("https://img-blog.csdnimg.cn/20210303104522231.png","我的博客圖片03.png");TestCallable t1 = new TestCallable("https://img-blog.csdnimg.cn/20210210194321356.png","我的博客圖片01.png");//創建執行服務ExecutorService ser = Executors.newFixedThreadPool(3);//提交執行Future<Boolean> r1 = ser.submit(t1);Future<Boolean> r2 = ser.submit(t2);Future<Boolean> r3 = ser.submit(t3);//獲取結果boolean res1 = r1.get();boolean res2 = r2.get();boolean res3 = r3.get();//關閉服務ser.shutdown();} }//下載器 class WebDownLoader{//下載方法public void downloader(String url, String name){try {FileUtils.copyURLToFile(new URL(url), new File(name)); //調用FileUtils類中的copyURLToFile方法實現下載} catch (IOException e) {e.printStackTrace();System.out.println("IO異常：downloader方法出現問題");}} }/* 已下載文件名為：我的博客圖片01.png的圖片 已下載文件名為：我的博客圖片03.png的圖片 已下載文件名為：我的博客圖片02.png的圖片Process finished with exit code 0 */多線程05：lambda表達式
Lambda 表達式，也可稱為閉包，它是推動 Java 8 發布的最重要新特性。
Lambda 允許把函數作為一個方法的參數（函數作為參數傳遞進方法中）。
使用 Lambda 表達式可以使代碼變的更加簡潔緊湊。
語法：
(parameters) -> expression 或 (parameters) -> {statements;}lambda表達式的重要特征：
可選類型聲明
不需要聲明參數類型，編譯器可以統一識別參數值。
可選的參數圓括號
一個參數無需定義圓括號，但多個參數需要定義圓括號
可選的大括號
如果主體包含了一個語句，就不需要使用大括號
可選的返回關鍵字
如果主體只有一個表達式返回值則編譯器會自動返回值，大括號需要指明表達式返回了一個數值。
函數式接口(Functional Interface)就是一個有且僅有一個抽象方法，但是可以有多個非抽象方法的接口。
對于函數式接口我們可以使用lambda表達式來創建該接口的對象。
//1.定義一個函數式接口 interface ILike{void lambda(); }//6.用lambda簡化ILike like5 = ()-> {System.out.println("I like Lambda5");};like5.lambda();/* 輸出：I like Lambda5 */下面是推導lambda表達式的過程，一步一步化簡，思路是先從用類實現接口，到靜態內部類，到局部內部類，再到匿名內部類，一步步簡化，到最后是lambda表達式。
package lishizheng.demo03;//推導lambda表達式 public class TestLambda {//3.靜態內部類static class Like2 implements ILike{@Overridepublic void lambda() {System.out.println("I like Lambda2");}}public static void main(String[] args) {Like like = new Like();like.lambda();Like2 like2 = new Like2();like2.lambda();//4. 局部內部類class Like3 implements ILike{@Overridepublic void lambda() {System.out.println("I like Lambda3");}}Like3 like3 = new Like3();like3.lambda();//5.匿名內部類,沒有類的名稱，必須借助接口或者父類ILike like4 = new ILike() {@Overridepublic void lambda() {System.out.println("I like Lambda4");}};like4.lambda();//6.用lambda簡化ILike like5 = ()-> {System.out.println("I like Lambda5");};like5.lambda();} }//1.定義一個函數式接口 interface ILike{void lambda(); }//2.實現類 class Like implements ILike{@Overridepublic void lambda() {System.out.println("I like Lambda");} }/* 輸出結果： I like Lambda I like Lambda2 I like Lambda3 I like Lambda4 I like Lambda5Process finished with exit code 0 */靜態代理模式
//真實對象和代理對象到實現同一個接口
//代理對象要代理真實對象
好處：代理對象可以做很多真實對象做不了的事情 ；真實對象專注于自己的事情
舉例：下面通過婚慶公司代理你來組織婚禮來說明一下靜態代理模式的功能。結婚之前要布置現場，然后主人結婚，結婚之后收尾款，這些方法都由婚慶公司對象來調用。
package lishizheng.demo04;//靜態代理模式//真實對象和代理對象到實現同一個接口 //代理對象到代理真實對象//好處：代理對象可以做很多真實對象做不了的事情 ；真實對象專注于自己的事情public class StaticProxy {public static void main(String[] args) {You you = new You();WeddingCompany weddingCompany = new WeddingCompany(you);weddingCompany.happyMarry();} }interface Marry{void happyMarry(); }class You implements Marry{@Overridepublic void happyMarry() {System.out.println("結婚，超開心");} }//代理角色 class WeddingCompany implements Marry{//代理誰？ 真實目標角色private Marry target;public WeddingCompany(Marry target) {this.target = target;}@Overridepublic void happyMarry() {before();this.target.happyMarry();//真實對象after();}private void after() {System.out.println("結婚之后收尾款");}private void before() {System.out.println("結婚之前布置現場");} } /* 輸出結果：結婚之前布置現場 結婚，超開心 結婚之后收尾款Process finished with exit code 0 */和多線程有什么關系呢？
復習Thread調用方法的時候，原理是一樣的，它本身是Runnable接口的代理。 下面通過婚慶公司和線程進行對比。
public class StaticProxy {public static void main(String[] args) {You you = new You();//Thread代理真實的Runnable接口，new Thread(() -> System.out.println("我愛你") ).start();new WeddingCompany(you).happyMarry();} }多線程06：線程狀態
停止線程stop
- 不推薦使用JDK提供的stop方法，destroy方法
- 推薦讓線程自己停止下來，建議使用標志位進行終止變量：當flag == false時，線程終止。
舉例如下： 測試主線程和teststop線程的執行過程，運行期間讓teststop停止。
package lishizheng.demo05;//測試stop //1.建議線程正常停止：利用此時，不建議死循環 //2.建議使用標志位 public class TestStop implements Runnable {// 1.設置一個標志位private boolean flag = true;@Overridepublic void run() {int i = 0;while (flag){System.out.println("run...Thread: " + i++);}}//2.設置公開的方法停止線程public void stop(){this.flag = false;}public static void main(String[] args) {TestStop testStop = new TestStop();new Thread(testStop).start();for (int i = 0; i < 30; i++) {System.out.println("main " +i);if( i == 20){//調用stop方法切換線程標志位，讓線程停止testStop.stop();System.out.println("線程已停止");}}} }/* 輸出結果： main 0 run...Thread: 0 main 1 run...Thread: 1 main 2 run...Thread: 2 main 3 run...Thread: 3 main 4 main 5 run...Thread: 4 main 6 run...Thread: 5 main 7 main 8 main 9 main 10 main 11 main 12 main 13 main 14 main 15 main 16 main 17 main 18 main 19 main 20 run...Thread: 6 線程已停止 main 21 main 22 main 23 main 24 main 25 main 26 main 27 main 28 main 29Process finished with exit code 0*/線程休眠sleep
- sleep指定當前線程阻塞的毫秒數，時間到后線程進入就緒狀態
- sleep存在異常InterruptedException，要拋出
- sleep可以模擬網絡延遲，倒計時等
- 每個對象都有一個鎖，sleep不會釋放鎖。
舉例：sleep模擬網絡延時，發現代碼的漏洞：這里是多線程操作同一個對象，造成線程不安全。通過sleep延時可以發現程序的執行過程并不是我們預計的那樣。
package lishizheng.demo05;//模擬網絡延時:放大問題的可能性，容易發現問題 public class TestSleep implements Runnable{private int ticketNums = 10;@Overridepublic void run() {while (true){if(ticketNums <= 0) break;try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}System.out.println( Thread.currentThread().getName() + "拿到了第 " + ticketNums-- +"張票");}}public static void main(String[] args) {//線程不安全：多個線程操作同一個對象TestSleep testThread4 = new TestSleep();new Thread(testThread4, "小明").start();new Thread(testThread4,"老師").start();new Thread(testThread4,"黃牛").start();} }/* 運行結果： 黃牛拿到了第 9張票 老師拿到了第 8張票 小明拿到了第 10張票 老師拿到了第 7張票 小明拿到了第 7張票 黃牛拿到了第 6張票 黃牛拿到了第 5張票 小明拿到了第 4張票 老師拿到了第 5張票 小明拿到了第 3張票 黃牛拿到了第 1張票 老師拿到了第 2張票Process finished with exit code 0 */舉例
模擬倒計時和模擬獲取系統時間
線程禮讓yield
線程禮讓，讓當前正在執行的線程暫停，但不阻塞；將線程從運行狀態轉為就緒狀態。讓CPU重新調度，禮讓不一定成功，看CPU心情。
測試：
package lishizheng.demo05;//測試禮讓線程 //禮讓不一定成功，看CPU心情 public class TestYield {public static void main(String[] args) {MyYield myYield = new MyYield();new Thread(myYield,"a").start();new Thread(myYield,"b").start();} }class MyYield implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"線程開始執行");Thread.yield();System.out.println(Thread.currentThread().getName()+"線程停止執行");} } /*a線程開始執行 b線程開始執行 a線程停止執行 b線程停止執行Process finished with exit code 0 */join
join相當于線程插隊，執行完插隊線程才能繼續執行別的線程。
測試：
觀察線程狀態：
多線程07：線程的優先級
每一個 Java 線程都有一個優先級，這樣有助于操作系統確定線程的調度順序。
Java 線程的優先級是一個整數，其取值范圍是 1 ~10（Thread.MIN_PRIORITY ~Thread.MAX_PRIORITY ）。
默認情況下，每一個線程都會分配一個優先級 NORM_PRIORITY（5）。
具有較高優先級的線程對程序更重要，并且應該在低優先級的線程之前分配處理器資源。但是，線程優先級不能保證線程執行的順序，而且非常依賴于平臺。 優先級高的線程，先執行的概率大。
測試線程優先級
package lishizheng.demo05;public class TestPriority {public static void main(String[] args) {//主線程默認優先級System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());MyPriority myPriority = new MyPriority();Thread t1 = new Thread(myPriority);Thread t2 = new Thread(myPriority);Thread t3 = new Thread(myPriority);Thread t4 = new Thread(myPriority);Thread t5 = new Thread(myPriority);//先設置優先級t1.start();t2.setPriority(1);t2.start();t3.setPriority(4);t3.start();t4.setPriority(Thread.MAX_PRIORITY);t4.start();} }class MyPriority implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());} }/* main--->5 Thread-0--->5 Thread-2--->4 Thread-3--->10 Thread-1--->1Process finished with exit code 0 */多線程08：守護線程(daemon)
守護線程是指為其他線程服務的線程。在JVM中，所有非守護線程都執行完畢后，無論有沒有守護線程，虛擬機都會自動退出。
線程分為用戶線程和守護線程，虛擬機必須確保用戶線程執行完畢，虛擬機不用等待守護線程執行完畢，守護線程比如監控內存、垃圾回收等。
測試用例：守護線程thread.setDaemon(true);//默認是false，表示是用戶線程會在JVM結束后接著運行一段時間。
package lishizheng.demo05;//測試守護線程 public class TestDaemon {public static void main(String[] args) {God god = new God();You you = new You();Thread thread = new Thread(god);thread.setDaemon(true);//默認是false，表示是用戶線程thread.start();//上帝線程new Thread(you).start();//用戶線程啟動} }class God implements Runnable{@Overridepublic void run() {while (true){System.out.println("上帝保佑著你");}} }class You implements Runnable{@Overridepublic void run() {for (int i = 1; i < 100; i++) {System.out.println("已經開心活過了"+ i +"年");}System.out.println("goodbye world");} }/* 部分運行結果 已經開心活過了92年 已經開心活過了93年 已經開心活過了94年 已經開心活過了95年 已經開心活過了96年 已經開心活過了97年 已經開心活過了98年 已經開心活過了99年 goodbye world 上帝保佑著你 上帝保佑著你 上帝保佑著你 上帝保佑著你 上帝保佑著你 Process finished with exit code 0*/多線程09：線程同步
線程同步是控制線程執行的先后順序。
線程同步：即當有一個線程在對內存進行操作時，其他線程都不可以對這個內存地址進行操作，直到該線程完成操作， 其他線程才能對該內存地址進行操作，而其他線程又處于等待狀態，實現線程同步的方法有很多，臨界區對象就是其中一種。
多線程同時讀寫共享變量時，會造成邏輯錯誤，因此需要通過synchronized同步；
線程不安全舉例：
package lishizheng.demo06;//不安全地買票 public class UnsafeBuyTicket {public static void main(String[] args) {BuyTicket buyTicket = new BuyTicket();new Thread(buyTicket,"小米").start();new Thread(buyTicket,"小明").start();new Thread(buyTicket,"黃牛").start();} }class BuyTicket implements Runnable{private int ticketNums = 10;boolean flag = true;@Overridepublic void run() {//模擬延時try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}//買票while (flag){buy();}}private void buy(){if(ticketNums <= 0) {flag = false;return;}System.out.println(Thread.currentThread().getName() + " 拿到" + ticketNums--);} }同步方法
同步塊：synchronized (Obj) {}，Obj稱為同步監視器。
- Obj可以是任何對象，但是推薦使用共享資源作為同步監視器
- 同步方法中無需指定同步監視器，因為同步方法的同步監視器就是this，就是這個對象本身或者是class
同步監視器的執行過程
擴充指示JUC：并發編程的安全性。
package lishizheng.demo06;import java.util.concurrent.CopyOnWriteArrayList;//測試JUC安全類型的集合 public class TestJUC {public static void main(String[] args) throws InterruptedException {CopyOnWriteArrayList<String > list = new CopyOnWriteArrayList<String >();for (int i = 0; i < 10000; i++) {new Thread(() -> {list.add(Thread.currentThread().getName());}).start();}Thread.sleep(3000);System.out.println(list.size());} }多線程10：死鎖
多個線程各自占有一些共享資源，并且互相等待其他線程占有的資源才能運行，而導致兩個或多個線程都在等待對方釋放資源，都停止運行的情形。某個同步塊擁有"兩個以上對象的鎖"時，就可能發生死鎖。
死鎖舉例 ：
灰姑娘和白雪公主都喜歡化妝，這里的化妝需要鏡子和口紅兩者都具備才能完成。 當灰姑娘拿到口紅，而白雪拿到鏡子的時候，兩者相互等待，這樣就構成死鎖。
程序進入死鎖（卡死），如下圖：
測試代碼：
死鎖避免的方法
產生死鎖的四個必要條件：
只要想辦法破壞上面任意一個或者多個就可以避免死鎖。
Lock（鎖）
從JDK 5.0開始，Java提供了更強大的線程同步機制：通過顯式定義同步鎖對象來實現同步。同步鎖使用Lock對象充當。java.util.concurrent.locks.Lock接口是控制多個線程對共享資源進行訪問的工具。
鎖提供了對共享資源的獨占訪問，每次只能有1個對象對Lock對象加鎖，線程開始訪問共享資源之前要先獲得Lock對象。
ReentrantLock類實現了Lock，它擁有了與synchronized相同的并發性和內存語義，在實現線程安全的控制中，比較常用的是ReentrantLock，可以顯式加鎖、釋放鎖。
測試代碼：使用reentrantLock顯式定義鎖和解鎖。
package lishizheng.advance;import java.util.concurrent.locks.ReentrantLock;//測試Lock鎖 public class TestLock {public static void main(String[] args) {TestLock2 testLock2 = new TestLock2();new Thread(testLock2).start();new Thread(testLock2).start();new Thread(testLock2).start();} }class TestLock2 implements Runnable{private int ticketNums = 10;//定義lock鎖//可重入鎖 re + entrant + lock private final ReentrantLock lock = new ReentrantLock();@Overridepublic void run() {while (true){try {lock.lock();//加鎖if(ticketNums > 0){try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(ticketNums--);}else break;}finally {//解鎖lock.unlock();}}} }synchronized 和Lock對比
多線程11：線程協作
生產者消費者問題
生產者消費者問題（英語：Producer-consumer problem），也稱有限緩沖問題（Bounded-buffer problem），是一個多進程同步問題的經典案例。該問題描述了共享固定大小緩沖區的兩個進程——即所謂的“生產者”和“消費者”——在實際運行時會發生的問題。生產者的主要作用是生成一定量的數據放到緩沖區中，然后重復此過程。與此同時，消費者也在緩沖區消耗這些數據。該問題的關鍵就是要保證生產者不會在緩沖區滿時加入數據，消費者也不會在緩沖區中空時消耗數據。
來源：維基百科
線程通信
Java提供了幾個方法解決線程之間的通信問題
| wait() | 表示線程一直等待，直到其他線程的通知，會釋放鎖 |
| wait(long tiimeout) | 指定等待的毫秒數 |
| notify() | 喚醒一個處于等待狀態的線程 |
| notifyAll() | 喚醒同一個對象上所有調用wait()方法的線程，優先級別高的線程優先被調度 |
注意：均為Object類的方法，都只能在同步方法或者同步代碼塊中使用，否則會拋出異常IllegalMonitorStateException.
解決方法1：管程法
生產者將生產好的數據放入緩沖區，消費者從緩沖區拿數據。
package lishizheng.demo06;//測試生產者消費者，利用緩沖區解決，即管程法//what do we need? //生產者，消費者，產品，緩沖區 public class TestPC {public static void main(String[] args) {SynContainer container = new SynContainer();new Producer(container).start();new Consumer(container).start();} }//生產者 class Producer extends Thread{SynContainer container;public Producer( SynContainer container){this.container = container;}//生產@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("生產了 " + i + "只雞");container.push(new Chicken(i));}} }//消費者class Consumer extends Thread{SynContainer container;public Consumer( SynContainer container){this.container = container;}//消費@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("消費了第 " + container.pop().id + " 只雞");}} }//產品class Chicken{int id;public Chicken(int id) {this.id = id;} }//緩沖區 class SynContainer{//容器大小10Chicken[] chickens = new Chicken[10];//容器計數器int count = 0;//生產者放入產品public synchronized void push(Chicken myChicken){//如果容器滿了,等待消費者消費if(count == 10){//通知消費者消費，生產者等待try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}//如果未滿，則放入產品chickens[count] = myChicken;count++;//進程通信，通知 消費者消費this.notifyAll();}//消費者消費產品public synchronized Chicken pop(){//判斷能否消費if(count == 0){//等待生產者生產,消費者等待try {wait();} catch (InterruptedException e) {e.printStackTrace();}}//如果可以消費count --;Chicken chicken = chickens[count];//吃完了，通知生產者生產this.notifyAll();return chicken;} }解決方法2：信號燈法
暫無。
參考資料
[1]https://www.bilibili.com/video/BV1V4411p7EF?p=1
[2]https://www.runoob.com/java/java-multithreading.html
感謝您閱讀到最后，祝您一切順利。
總結
以上是生活随笔為你收集整理的Java多线程详解[狂神说Java]的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Java入门学习笔记[狂神说Java]
- 下一篇： IDEA中Java项目如何新建JUnit