感覺對你有用，右邊點個贊哈！

知識點

應(yīng)該了解的概念

1. 線程與進程

進程是指一個內(nèi)存中運行的應(yīng)用程序，每個進程都有自己獨立的一塊內(nèi)存空間，一個進程中可以啟動多個線程。比如在 Windows 系統(tǒng)中，一個運行的 exe 就是一個進程。

線程是指進程中的一個執(zhí)行流程，一個進程中可以運行多個線程。比如java.exe 進程中可以運行很多線程。線程總是屬于某個進程，進程中的多個線程共享進程的內(nèi)存。

1.1 區(qū)別

并發(fā)性：進程之間可以并發(fā)執(zhí)行，同一個進程的多個線程之間也可并發(fā)執(zhí)行。

調(diào)度：線程作為調(diào)度和分配的基本單位，進程作為擁有資源的基本單位 。

根本區(qū)別：進程是操作系統(tǒng)資源分配的基本單位，而線程是任務(wù)調(diào)度和執(zhí)行的基本單位

開銷方面：每個進程都有獨立的代碼和數(shù)據(jù)空間（程序上下文），進程之間切換開銷大；線程可以看做輕量級的進程，同一類線程共享代碼和數(shù)據(jù)空間，每個線程都有自己獨立的運行棧和程序計數(shù)器（PC），線程之間切換的開銷小

包含關(guān)系：線程是進程的一部分，所以線程也被稱為輕權(quán)進程或者輕量級進程

2. 臨界區(qū)

臨界區(qū)用來表示一種公共資源或者說是共享數(shù)據(jù)，可以被多個線程使用。但是每個線程使用時，一旦臨界區(qū)資源被一個線程占有，那么其他線程必須等待。多個進程必須互斥的對它進行訪問。

3. 同步VS異步

同步方法：調(diào)用者必須等待被調(diào)用的方法結(jié)束后，調(diào)用者后面的代碼才能執(zhí)行

異步調(diào)用：調(diào)用者不用管被調(diào)用方法是否完成，都會繼續(xù)執(zhí)行后面的代碼，當(dāng)被調(diào)用的方法完成后會通知調(diào)用者。

4. 并發(fā)與并行

并發(fā)：多個任務(wù)交替進行，（類似單個 CPU ，通過 CPU 調(diào)度算法等，處理多個任務(wù)的能力，叫并發(fā)）

并行：真正意義上的“同時進行”。（類似多個 CPU ，同時并且處理相同多個任務(wù)的能力，叫做并行）

5. 阻塞和非阻塞

阻塞和非阻塞通常用來形容多線程間的相互影響，比如一個線程占有了臨界區(qū)資源，那么其他線程需要這個資源就必須進行等待該資源的釋放，會導(dǎo)致等待的線程掛起，這種情況就是阻塞，而非阻塞就恰好相反，它強調(diào)沒有一個線程可以阻塞其他線程，所有的線程都會嘗試地往前運行。

線程與多線程

1. 什么是線程

線程是操作系統(tǒng)能夠進行運算調(diào)度的最小單位，它被包含在進程之中，是進程中的實際運作單位。

2. 為什么需要多線程以及出現(xiàn)的問題

CPU、內(nèi)存、I/O 設(shè)備的速度是有極大差異的，為了合理利用 CPU 的高性能，平衡這三者的速度差異，計算機體系結(jié)構(gòu)、操作系統(tǒng)、編譯程序都做出了貢獻

• CPU 增加了緩存，以均衡與內(nèi)存的速度差異；// 導(dǎo)致 可見性問題
• 操作系統(tǒng)增加了進程、線程，以分時復(fù)用 CPU，進而均衡 CPU 與 I/O 設(shè)備的速度差異；// 導(dǎo)致 原子性問題
• 編譯程序優(yōu)化指令執(zhí)行次序，使得緩存能夠得到更加合理地利用。// 導(dǎo)致 有序性問題
  

3. 線程的特征

main()方法是個天然的多線程程序 所有的Java 程序，不論并發(fā)與否，都有一個名為主線程的Thread 對象。執(zhí)行該程序時， Java虛擬機（ JVM ）將創(chuàng)建一個新Thread 并在該線程中執(zhí)行main()方法。這是非并發(fā)應(yīng)用程序中唯一的線程，也是并發(fā)應(yīng)用程序中的第一個線程。

Java中的線程共享應(yīng)用程序中的所有資源，包括內(nèi)存和打開的文件，快速而簡單地共享信息。但是必須使用同步避免數(shù)據(jù)競爭

Java中的所有線程都有一個優(yōu)先級，這個整數(shù)值介于Thread.MIN_PRIORITY（1）和Thread.MAX_PRIORITY（10）之間，默認優(yōu)先級是Thread.NORM_PRIORITY（5）。線程的執(zhí)行順序并沒有保證，通常，較高優(yōu)先級的線程將在較低優(yōu)先級的線程之前執(zhí)行。

4. 線程狀態(tài)

• 創(chuàng)建(NEW)：新創(chuàng)建了一個線程對象，但還沒有調(diào)用 start() 方法。
• 運行(RUNNABLE)：Java 線程中將就緒（ready）和運行中（running）兩種狀態(tài)籠統(tǒng)的稱為“運行”。

線程對象創(chuàng)建后，其他線程(比如 main 線程）調(diào)用了該對象的 start() 方法。該狀態(tài)的線程位于可運行線程池中，等待被線程調(diào)度選中，獲取 CPU 的使用權(quán)，此時處于就緒狀態(tài)（ready）。就緒狀態(tài)的線程在獲得 CPU 時間片后變?yōu)檫\行中狀態(tài)（running）。

• 阻塞(BLOCKED)：表示線程阻塞于鎖。線程的執(zhí)行過程中由于一些原因進入阻塞狀態(tài)比如：調(diào)用 sleep 方法、嘗試去得到一個鎖等等
• 超時等待(TIMED_WAITING)：該狀態(tài)不同于WAITING，它可以在指定的時間后自行返回。
• 等待(WAITING)：進入該狀態(tài)的線程需要等待其他線程做出一些特定動作（通知或中斷）。
• 終止(TERMINATED)：表示該線程已經(jīng)執(zhí)行完畢。
• 運行(running)：CPU 開始調(diào)度線程，并開始執(zhí)行 run 方法
• 消亡(dead)：run 方法執(zhí)行完 或者 執(zhí)行過程中遇到了一個異常

5. 使用多線程一定快嗎？

答：不一定，因為多線程會進行上下文切換，上下文切換會帶來開銷。

5.1 什么是上下文切換？

單核在一個時刻只能運行一個線程，當(dāng)在運行一個線程的過程中轉(zhuǎn)去運行另外一個線程，這個叫做線程上下文切換（對于進程也是類似）。

線程上下文切換過程中會記錄 程序計數(shù)器、CPU 寄存器 的 狀態(tài)等數(shù)據(jù)。

5.2 如何減少上下文切換？

5.2.1 減少線程的數(shù)量

由于一個CPU每個時刻只能執(zhí)行一條線程，而傲嬌的我們又想讓程序并發(fā)執(zhí)行，操作系統(tǒng)只好不斷地進行上下文切換來使我們從感官上覺得程序是并發(fā)執(zhí)的行。因此，我們只要減少線程的數(shù)量，就能減少上下文切換的次數(shù)。

5.2.2 控制同一把鎖上的線程數(shù)量

多條線程共用同一把鎖，那么當(dāng)一條線程獲得鎖后，其他線程就會被阻塞；當(dāng)該線程釋放鎖后，操作系統(tǒng)會從被阻塞的線程中選一條執(zhí)行，從而又會出現(xiàn)上下文切換

因此，減少同一把鎖上的線程數(shù)量也能減少上下文切換的次數(shù)

5.2.3 采用無鎖并發(fā)編程

• 需要并發(fā)執(zhí)行的任務(wù)是無狀態(tài)的：HASH分段

所謂無狀態(tài)是指并發(fā)執(zhí)行的任務(wù)沒有共享變量，他們都獨立執(zhí)行。對于這種類型的任務(wù)可以按照ID進行HASH分段，每段用一條線程去執(zhí)行。

• 需要并發(fā)執(zhí)行的任務(wù)是有狀態(tài)的：CAS算法

如果任務(wù)需要修改共享變量，那么必須要控制線程的執(zhí)行順序，否則會出現(xiàn)安全性問題。你可以給任務(wù)加鎖，保證任務(wù)的原子性與可見性，但這會引起阻塞，從而發(fā)生上下文切換；為了避免上下文切換，你可以使用CAS算法， 僅在線程內(nèi)部需要更新共享變量時使用CAS算法來更新，這種方式不會阻塞線程，并保證更新過程的安全性(具體的方式后面的文章會將)。

6. 使用多線程的缺點

6.1 上下文切換的開銷

當(dāng) CPU 從執(zhí)行一個線程切換到執(zhí)行另外一個線程的時候，它需要先存儲當(dāng)前線程的本地的數(shù)據(jù)，程序指針等，然后載入另一個線程的本地數(shù)據(jù)，程序指針等，最后才開始執(zhí)行。這種切換稱為“上下文切換”。CPU 會在一個上下文中執(zhí)行一個線程，然后切換到另外一個上下文中執(zhí)行另外一個線程。上下文切換并不廉價。如果沒有必要，應(yīng)該減少上下文切換的發(fā)生。

6.2 增加資源消耗

線程在運行的時候需要從計算機里面得到一些資源。 除了 CPU，線程還需要一些 內(nèi)存來維持它本地的堆棧。它也需要 占用操作系統(tǒng)中一些資源來管理線程

6.3 編程更復(fù)雜

在多線程訪問共享數(shù)據(jù)的時候，要考慮線程安全問題

7. 線程狀態(tài)的基本操作

線程在生命周期內(nèi)還有需要基本操作，而這些操作會成為線程間一種通信方式，比如使用中斷（interrupted）方式通知實現(xiàn)線程間的交互等等

7.1 interrupted

中斷可以理解為線程的一個標志位，它表示了一個運行中的線程是否被其他線程進行了中斷操作。中斷好比其他線程對該線程打了一個招呼。其他線程可以調(diào)用該線程的interrupt()方法對其進行中斷操作，同時該線程可以調(diào)用 isInterrupted（）來感知其他線程對其自身的中斷操作，從而做出響應(yīng)。另外，同樣可以調(diào)用Thread的靜態(tài)方法 interrupted（）對當(dāng)前線程進行中斷操作，該方法會清除中斷標志位。需要注意的是，當(dāng)拋出InterruptedException時候，會清除中斷標志位，也就是說在調(diào)用isInterrupted會返回false。

public class InterruptDemo {public static void main(String[] args) throws InterruptedException {//sleepThread睡眠1000msfinal Thread sleepThread = new Thread() {@Overridepublic void run() {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}super.run();}};//busyThread一直執(zhí)行死循環(huán)Thread busyThread = new Thread() {@Overridepublic void run() {while (true) ;}};sleepThread.start();busyThread.start();sleepThread.interrupt();busyThread.interrupt();while (sleepThread.isInterrupted()) ;System.out.println("sleepThread isInterrupted: " + sleepThread.isInterrupted());System.out.println("busyThread isInterrupted: " + busyThread.isInterrupted());} }

開啟了兩個線程分別為sleepThread和BusyThread, sleepThread睡眠1s，BusyThread執(zhí)行死循環(huán)。然后分別對著兩個線程進行中斷操作，可以看出sleepThread拋出InterruptedException后清除標志位，而busyThread就不會清除標志位。

另外，同樣可以通過中斷的方式實現(xiàn)線程間的簡單交互， while (sleepThread.isInterrupted()) 表示在Main中會持續(xù)監(jiān)測sleepThread，一旦sleepThread的中斷標志位清零，即sleepThread.isInterrupted()返回為false時才會繼續(xù)Main線程才會繼續(xù)往下執(zhí)行。因此，中斷操作可以看做線程間一種簡便的交互方式。一般在結(jié)束線程時通過中斷標志位或者標志位的方式可以有機會去清理資源，相對于武斷而直接的結(jié)束線程，這種方式要優(yōu)雅和安全。

7.2 join

join方法可以看做是線程間協(xié)作的一種方式，很多時候，一個線程的輸入可能非常依賴于另一個線程的輸出，這就像兩個好基友，一個基友先走在前面突然看見另一個基友落在后面了，這個時候他就會在原處等一等這個基友，等基友趕上來后，就兩人攜手并進。其實線程間的這種協(xié)作方式也符合現(xiàn)實生活。在軟件開發(fā)的過程中，從客戶那里獲取需求后，需要經(jīng)過需求分析師進行需求分解后，這個時候產(chǎn)品，開發(fā)才會繼續(xù)跟進。

join方法源碼關(guān)鍵是：

while (isAlive()) {wait(0);}

線程的合并是指將某一個線程A在調(diào)用A.join()方法合并到正在運行的另一個線程B中，此時線程B處于阻塞狀態(tài)需要等到線程A執(zhí)行完畢后才開始線程B的繼續(xù)執(zhí)行

public class JoinDemo {public static void main(String[] args) throws InterruptedException {TestThread t = new TestThread();Thread t1 = new Thread(t);t1.start();for (int i = 0; i < 100; i++) {/*** 當(dāng)main線程中的i等于50的時候，就把t1線程合并到main線程中執(zhí)行。此時main線程是處于阻塞狀態(tài)* 直到t1線程執(zhí)行完成后，main才開始繼續(xù)執(zhí)行*/if (50==i) {t1.join();}System.out.println("main.."+i);} } } class TestThread implements Runnable{@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("join.."+i);} } }

7.3 sleep

public static native void sleep(long millis)方法顯然是Thread的靜態(tài)方法，很顯然它是讓當(dāng)前線程按照指定的時間休眠，其休眠時間的精度取決于處理器的計時器和調(diào)度器。需要注意的是如果當(dāng)前線程獲得了鎖，sleep方法并不會失去鎖。

public static void main(String[] args) throws InterruptedException {int num = 10;while (true) {System.out.println(num--);Thread.sleep(1000);if (num<=0) {break; }} }

7.4 yield

該暫停方法暫停的時候不一定就暫停了，取決于CPU，假如剛暫停CPU調(diào)度又調(diào)到了該線程那就又啟動了…

public class YieldDemo {public static void main(String[] args) throws InterruptedException {TestThread1 t = new TestThread1();Thread t1 = new Thread(t);t1.start();for (int i = 0; i < 100; i++) {//當(dāng)main線程中的i是20的倍數(shù)時，就暫停main線程if (i%20==0) {Thread.yield();//yield寫在哪個線程體中，就暫停哪個線程。這里是在main里，就暫停main線程System.out.println("main線程暫停");}System.out.println("main.."+i);} } } class TestThread1 implements Runnable{@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("join.."+i);} } }

8. 兩類線程

8.1 用戶線程(User Thread)

User和Daemon兩者幾乎沒有區(qū)別，唯一的不同之處就在于虛擬機的離開：如果 User Thread已經(jīng)全部退出運行了，只剩下Daemon Thread存在了，虛擬機也就退出了。

8.2 守護線程(Daemon Thread)

Daemon的作用是為其他線程的運行提供便利服務(wù)，守護線程最典型的應(yīng)用就是 GC (垃圾回收器)

當(dāng)所有非守護線程結(jié)束時，程序也就終止，同時會殺死所有守護線程。main() 屬于非守護線程。

使用 setDaemon() 方法將一個線程設(shè)置為守護線程。

8.2.1 需要注意

• thread.setDaemon(true)必須在thread.start()之前設(shè)置，否則會拋出一個IllegalThreadStateException異常。你不能把正在運行的常規(guī)線程設(shè)置為守護線程。
• 在Daemon線程中產(chǎn)生的新線程也是Daemon的
• 不要認為所有的應(yīng)用都可以分配給Daemon來進行服務(wù)，比如讀寫操作或者計算邏輯。

8.2.2 守護線程的代碼實踐

• 前臺線程是保證執(zhí)行完畢的，后臺線程還沒有執(zhí)行完畢就退出了。

public class Test { public static void main(String args) { Thread t1 = new MyCommon(); Thread t2 = new Thread(new MyDaemon()); t2.setDaemon(true); //設(shè)置為守護線程 t2.start(); t1.start(); } } class MyCommon extends Thread { public void run() { for (int i = 0; i < 5; i++) { System.out.println("線程1第" + i + "次執(zhí)行！"); try { Thread.sleep(7); } catch (InterruptedException e) { e.printStackTrace(); } } } } class MyDaemon implements Runnable { public void run() { for (long i = 0; i < 9999999L; i++) { System.out.println("后臺線程第" + i + "次執(zhí)行！"); try { Thread.sleep(7); } catch (InterruptedException e) { e.printStackTrace(); } } } }

執(zhí)行結(jié)果：

后臺線程第0次執(zhí)行！線程1第0次執(zhí)行！ 線程1第1次執(zhí)行！ 后臺線程第1次執(zhí)行！ 后臺線程第2次執(zhí)行！ 線程1第2次執(zhí)行！ 線程1第3次執(zhí)行！ 后臺線程第3次執(zhí)行！ 線程1第4次執(zhí)行！ 后臺線程第4次執(zhí)行！ 后臺線程第5次執(zhí)行！ 后臺線程第6次執(zhí)行！ 后臺線程第7次執(zhí)行！

• 守護線程在退出的時候并不會執(zhí)行finnaly塊中的代碼，所以將釋放資源等操作不要放在finnaly塊中執(zhí)行，這種操作是不安全的

public class DaemonDemo {public static void main(String[] args) {Thread daemonThread = new Thread(new Runnable() {@Overridepublic void run() {//daemodThread run方法中是一個while死循環(huán)while (true) {try {System.out.println("i am alive");Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();} finally {System.out.println("finally block");}}}});daemonThread.setDaemon(true);daemonThread.start();//確保main線程結(jié)束前能給daemonThread能夠分到時間片try {Thread.sleep(800);} catch (InterruptedException e) {e.printStackTrace();}} }

執(zhí)行結(jié)果

i am alive finally block i am alive

daemodThread run方法中是一個while死循環(huán)，會一直打印,但是當(dāng)main線程結(jié)束后daemonThread就會退出所以不會出現(xiàn)死循環(huán)的情況。

main線程先睡眠800ms保證daemonThread能夠擁有一次時間片的機會，也就是說可以正常執(zhí)行一次打印“i am alive”操作和一次finally塊中"finally block"操作。

緊接著main 線程結(jié)束后，daemonThread退出，這個時候只打印了"i am alive"并沒有打印finnal塊中的。

守護線程在退出的時候并不會執(zhí)行finnaly塊中的代碼，所以將釋放資源等操作不要放在finnaly塊中執(zhí)行，這種操作是不安全的

8.2.3 特點

• 因為是守護線程，或者說是支持性線程，就意味著這個線程并不屬于程序中不可或缺的一部分。所以當(dāng)所有的非守護線程（即用戶線程）結(jié)束之后，程序就會結(jié)束，JVM退出，同時也就會殺死所有的非守護線程。所以也就意味著，守護線程不適合去訪問固有資源，比如文件，數(shù)據(jù)庫。因為隨時可能中斷。

• 后臺線程會隨著主程序的結(jié)束而結(jié)束，但是前臺進程則不會，或者說只要有一個前臺線程未退出，進程就不會終止。

• 默認情況下，程序員創(chuàng)建的線程是用戶線程；用setDaemon(true)可以設(shè)置線程為后臺線程；而用isDaemon( )則可以判斷一個線程是前臺線程還是后臺線程；

• jvm的垃圾回收器其實就是一個后臺線程；

• setDaemon函數(shù)必須在start函數(shù)之前設(shè)定，否則會拋出IllegalThreadStateException異常;

8.2.4 使用場景

• qq,飛訊等等聊天軟件,主程序是非守護線程,而所有的聊天窗口是守護線程 ,當(dāng)在聊天的過程中,直接關(guān)閉聊天應(yīng)用程序時,聊天窗口也會隨之關(guān)閉,但是不是 立即關(guān)閉,而是需要緩沖,等待接收到關(guān)閉命令后才會執(zhí)行窗口關(guān)閉操作.

• jvm中,gc線程是守護線程,作用就是當(dāng)所有用戶自定義線以及主線程執(zhí)行完畢后, gc線程才停止

• Web服務(wù)器中的Servlet，在容器啟動時，后臺都會初始化一個服務(wù)線程，即調(diào)度線程，負責(zé)處理http請求，然后每個請求過來，調(diào)度線程就會從線程池中取出一個工作者線程來處理該請求，從而實現(xiàn)并發(fā)控制的目的。也就是說，一個實際應(yīng)用在Java的線程池中的調(diào)度線程

8.2.5 總結(jié)

守護線程就是用來告訴JVM，我的這個線程是一個低級別的線程，不需要等待它運行完才退出，讓JVM喜歡什么時候退出就退出，不用管這個線程。

在日常的業(yè)務(wù)相關(guān)的CRUD開發(fā)中，其實并不會關(guān)注到守護線程這個概念，也幾乎不會用上。

但是如果要往更高的地方走的話，這些深層次的概念還是要了解一下的，比如一些框架的底層實現(xiàn)。

7. 線程安全

7.1 什么是線程安全？

所有的隱患都是在多個線程訪問的情況下產(chǎn)生的，也就是我們要確保在多條線程訪問的時候，我們的程序還能按照我們預(yù)期的行為去執(zhí)行.

下面代碼需要在多線程環(huán)境下的測試

Integer count = 0;public void getCount() {count ++;System.out.println(count);} //開三個線程代碼，值會重復(fù) 所以在多線程的情況下

結(jié)論:

當(dāng)多個線程訪問某個方法時，不管你通過怎樣的調(diào)用方式、或者說這些線程如何交替地執(zhí)行，我們在主程序中不需要去做任何的同步，這個類的結(jié)果行為都是我們設(shè)想的正確行為，那么我們就可以說這個類是線程安全的。

7.2 什么時候會出現(xiàn)線程安全?

• 線程安全問題都是由全局變量及靜態(tài)變量引起的。若每個線程中對全局變量、靜態(tài)變量只有讀操作，而無寫操作，一般來說，這個全局變量是線程安全的；

• 若有多個線程同時執(zhí)行寫操作，一般都需要考慮線程同步，否則的話就可能出現(xiàn)線程安全的問題。

7.3 有哪些方法可以保證線程安全嗎?

7.3.1 synchronized

7.3.1.1 同步代碼塊

synchronized 關(guān)鍵字可以用于方法中的某個區(qū)塊中，表示只對這個區(qū)塊的資源實行互斥訪問。

synchronized關(guān)鍵字就是用來控制線程同步的，保證我們的線程在多線程環(huán)境下，不被多個線程同時執(zhí)行，確保我們數(shù)據(jù)的完整性，使用方法一般是加在方法上。

• 代碼塊中的鎖對象可以是任意對象；

• 但是必須保證多個線程使用的鎖對象是同一個；

• 鎖對象的作用就是將同步代碼塊鎖住，只允許一個線程在同步代碼塊中執(zhí)行

// 創(chuàng)建一個鎖對象Object object = new Object();int count = 0; // 記錄方法的命中次數(shù)// 創(chuàng)建同步代碼塊synchronized (object) {if (ticket > 0) {count++ ;int i = 1;j = j + i;}}

注意：

• synchronized鎖的是括號里的對象，而不是代碼，其次，對于非靜態(tài)的synchronized方法，鎖的是對象本身也就是this
• synchronized鎖住一個對象之后，別的線程如果想要獲取鎖對象，那么就必須等這個線程執(zhí)行完釋放鎖對象之后才可以，否則一直處于等待狀態(tài)。
• 加synchronized關(guān)鍵字，可以讓我們的線程變得安全，但是我們在用的時候，也要注意縮小synchronized的使用范圍，如果隨意使用時很影響程序的性能，別的對象想拿到鎖，結(jié)果你沒用鎖還一直把鎖占用，這樣就有點浪費資源。

7.3.1.2 同步方法

使用 synchronized 修飾的方法,就叫做同步方法,保證A線程執(zhí)行該方法的時候,其他線程只能在方法外等著

int count = 0; // 記錄方法的命中次數(shù)public synchronized void threadMethod(int j) {count++ ;int i = 1;j = j + i;}

7.3.2 同步鎖(Lock)

java.util.concurrent.locks.Lock 機制提供了比 synchronized 代碼塊和 synchronized 方法更廣泛的鎖定操作，同步代碼塊/同步方法具有的功能 Lock 都有,除此之外更強大,更體現(xiàn)面向?qū)ο蟆?/p>

Lock 鎖使用步驟：

在成員位置創(chuàng)建一個 ReentrantLock 對象；

在可能出現(xiàn)安全問題的代碼前調(diào)用 Lock 接口中的方法lock();

在可能出現(xiàn)安全問題的代碼前調(diào)用 Lock 接口中的方法unLock();

7.3.2.1 lock.lock()

跟synchronized不同的是，Lock獲取的所對象需要我們親自去進行釋放，為了防止我們代碼出現(xiàn)異常，所以我們的釋放鎖操作放在finally中，因為finally中的代碼無論如何都是會執(zhí)行的。

private Lock lock = new ReentrantLock(); // ReentrantLock是Lock的子類private void method(Thread thread){lock.lock(); // 獲取鎖對象try {System.out.println("線程名："+thread.getName() + "獲得了鎖");// Thread.sleep(2000);}catch(Exception e){e.printStackTrace();} finally {System.out.println("線程名："+thread.getName() + "釋放了鎖");lock.unlock(); // 釋放鎖對象} }

7.3.2.2 lock.tryLock()

tryLock()這個方法跟Lock()是有區(qū)別的，Lock在獲取鎖的時候，如果拿不到鎖，就一直處于等待狀態(tài)，直到拿到鎖，但是tryLock()卻不是這樣的，tryLock是有一個Boolean的返回值的，如果沒有拿到鎖，直接返回false，停止等待，它不會像Lock()那樣去一直等待獲取鎖。

private void method(Thread thread){// lock.lock(); // 獲取鎖對象if (lock.tryLock()) {try {System.out.println("線程名："+thread.getName() + "獲得了鎖");// Thread.sleep(2000);}catch(Exception e){e.printStackTrace();} finally {System.out.println("線程名："+thread.getName() + "釋放了鎖");lock.unlock(); // 釋放鎖對象}}}

7.3.2.3 lock.tryLock(5,TimeUnit.SECONDS)

一種方式來控制一下，讓后面等待的線程，可以等待5秒，如果5秒之后，還獲取不到鎖，那么就停止等，其實tryLock()是可以進行設(shè)置等待的相應(yīng)時間的。

private void method(Thread thread) throws InterruptedException {// lock.lock(); // 獲取鎖對象// 如果5秒內(nèi)獲取不到鎖對象，那就不再等待if (lock.tryLock(5,TimeUnit.SECONDS)) {try {System.out.println("線程名："+thread.getName() + "獲得了鎖");}catch(Exception e){e.printStackTrace();} finally {System.out.println("線程名："+thread.getName() + "釋放了鎖");lock.unlock(); // 釋放鎖對象}} }

嘮嘮嗑

如果有一絲收獲,歡迎在看、點贊、轉(zhuǎn)發(fā)，您的認可是我最大的動力。

與50位技術(shù)專家面對面20年技術(shù)見證，附贈技術(shù)全景圖

總結(jié)

以上是生活随笔為你收集整理的最新最全的java多线程基础总结(上)的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。