目錄1. 你知道線程安全問題嗎？2. 那如何解決線程安全問題呢？3. 那你講下死鎖是什么吧？總結1. 你知道線程安全問題嗎？

線程安全問題：一般指在多線程模式下，多個線程對同一個共享數據進行操作時，第一個線程還沒來得及更新共享數據，從而導致另外一個線程沒得到最新的數據，并更新數據，從而產生線程安全問題。比較常見的場景有買票。

我舉個例子吧：

需求：比如買周杰倫演唱會的門票，此時有三個窗口同時賣總共100張票。窗口就是線程對象，而100張票的資源，此時就相當于多個線程去搶占cpu的資源去搶對票的使用權。

嘿嘿，這是在大學時期和MyGirl去看滴，現在想去看也沒辦法了。話不多說，我們還是來看看代碼吧：

public class SellTicketDemo { public static void main(String[] args) {// 創建線程任務對象Ticket ticket = new Ticket();//創建三個窗口對象Thread thread = new Thread(ticket, '窗口1');Thread thread2 = new Thread(ticket, '窗口2');Thread thread3 = new Thread(ticket, '窗口3');//同時賣票thread.start();thread2.start();thread3.start(); }}// 創建Ticket實現Runnaleclass Ticket implements Runnable { private int ticket = 100; // 100張周杰倫演唱會門票 // 執行買票的邏輯 @Override public void run() {// 注意每個窗口都有賣票的權利while (true) { if (ticket > 0) { // 有票 可以賣// 出票: 因為進來買票，總有出票，總會慢慢沒票的吧try { // 這里采用sleep稍微等待下，模擬一下出票時間 。 Thread.sleep(100);} catch (InterruptedException e) { e.printStackTrace();}// 獲取當前線程對象的名字System.out.println(Thread.currentThread().getName() + '正在賣:' + ticket--); }} }}

這里講下： 我們創建了Ticket實現Runnable接口，并重寫里面的run方法實現買票的功能，并定義了一個共享的變量。并在main方法中創建了三個線程去實現三個窗口買票的功能。最后我們來看看結果吧：

在你多運行幾次，可以看到這樣的現象：

賣出了不存在的票，比如0票與-1票，是不存在滴。而且這種情況根本不允許發生呀，誰會賣0張甚至-1張票呢。 出現多賣相同的票數，比如8和1這張票被賣了三回。那這就很過分了呦，一張票還可以賣三個人哈哈。

這些問題的發生就代表我們剛才是線程不安全的了。那線程安全問題具體是什么呢？我們可以總結得到：

是由全局變量及靜態變量引起的。若每個線程中對全局變量、靜態變量只有讀操作，而無寫操作，一般來說，這個全局變量是線程安全的；若有多個線程同時執行寫操作，一般都需要考慮線程同步，否則的話就可能影響線程安全。

那可能發生線程安全問題的條件：

是否多線程環境下，單線程情況去對數據操作，當然是沒什么問題滴啦！ 是否存在共享變量，如上面的代碼中，定義了一個全局變量ticket的演唱會門票，多個線程會共享這一變量。 是否存在多條語句操作共享數據，如上面的代碼中，你在賣出票后，ticket變量肯定需要減少滴呀，所以對ticket進行了減的操作了。2. 那如何解決線程安全問題呢？

我們可以引入線程同步解決線程安全問題。在上面賣票問題中，多線程并發訪問一個資源的安全性問題：也就是解決重復票與不存在票問題，Java中提供了同步機制(synchronized )來解決。

即具體的解決思路是這樣的：

1.窗口1線程進入買票的時候，窗口2和窗口3線程只能在外等著，此時是不能進行買票的操作的，只能等待窗口1買票完畢后，就進入到窗口1和窗口2和窗口3再次搶占cpu的資源去執行賣票功能。

2.也就是說在某個線程修改共享資源的時候，其他線程不能修改該資源，等待修改完畢同步之后，才能去搶奪CPU資源，完成對應的操作，保證了數據的同步性，解決了線程不安全的現象。

而synchronized 關鍵字又給我們提供幾種方法呢：

1.實現同步代碼塊：synchronized 關鍵字可以用于方法中的某個區塊中，表示只對這個區塊的資源實行互斥訪問。

2.實現同步方法：使用synchronized 修飾的方法，就叫做同步方法，保證一個線程執行該方法的時候，其他線程只能在方法外等著。

public class SynchronizedDemo { // 加在方法上 實際是對this對象加鎖 private synchronized void synchronizedTest() { } // 同步代碼塊,鎖對象可以是任意的，可以使用this，或者類.class對象，或者任意對象都可以 private void synchronizedTest2(){synchronized (this){} } // 加在靜態方法上 實際是對類對象加鎖 private synchronized static void synchronizedTest3() { }}

除了synchronized 關鍵字，還有Lock 鎖，與此種方法需要自己定義鎖的釋放位置。

Lock lock = new ReentrantLock();lock.lock(); // 自己定義開啟鎖位置try { System. out. println('我們獲得了鎖');} catch (Exception e) {} finally { System. out. println('我們釋放了鎖'); lock.unlock();// 需要自己定義釋放鎖位置，不然會存在死鎖問題。}

那我們總結下：

我們怎么保證安全問題：

1.使用synchronized關鍵字，實現同步代碼塊或者同步方法。達到保證一個線程對資源操作的時候，其他線程只能等待。

2.用手動鎖 Lock，使用Lock鎖出現的位置可以相對比較靈活，但是必須有釋放鎖的配合動作。

兩者的區別：

synchronized 它是Java中的關鍵字，而Lock是一個類，它是個接口一般我們會使用ReentrantLock來創建實例對象。synchronized 它可以修飾在類、方法、變量中，可以實現同步代碼塊，而ReentrantLock只適用于代碼塊鎖。 synchronized 操作的應該是對象頭中 mark word，而ReentrantLock 底層調用的是 Unsafe 的park 方法加鎖。 ReentrantLock 必須手動獲取與釋放鎖，而synchronized 不需要手動釋放和開啟鎖。 兩者都是可重入鎖。可重入鎖就是允許同一個線程多次獲取同一把鎖，如果某個線程已經獲得某個鎖，自己可以再次獲取鎖而不會出現死鎖。而如果是不可鎖重入的話，就會造成死鎖。3. 那你講下死鎖是什么吧？

死鎖是指兩個或兩個以上的進程（線程）在執行過程中，由于競爭資源或者由于彼此通信而造成的一種阻塞的現象，若無外力作用，它們都將無法推進下去。此時稱系統處于死鎖狀態或系統產生了死鎖，這些永遠在互相等待的進程（線程）稱為死鎖進程（線程）。

舉個例子：你和你女朋友吵架，你們開始互掐頭發，你揪著她秀長的長發，而她揪著你寸頭，你們倆疼痛不比，但是彼此都是暴脾氣，彼此發狠的說你放不放，不放我也不放，看先疼死了！此時你們互相觀望著對方，喊著誓不放手。現在就相當產生了死鎖現象，互相等待。

我們來簡單演示下線程死鎖的代碼吧：

public class DeadlockDemo { public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();new Thread(myRunnable, '看戲觀眾1看到').start();new Thread(myRunnable, '看戲觀眾2看到').start(); }}class MyRunnable implements Runnable { Object me = new Object(); Object myGirl = new Object(); @Override public void run() {synchronized (me) { System.out.println(Thread.currentThread().getName() + 'me：我要掐死你！你放不放呀'); try {Thread.sleep(1000); } catch (InterruptedException e) {e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + 'me：你放手我就放手！'); synchronized (myGirl) {System.out.println(Thread.currentThread().getName() + 'me：你倒是快放手呀！你不疼嗎？'); }}synchronized (myGirl) { System.out.println(Thread.currentThread().getName() + 'myGirl：老娘我才要掐死你！你還不放？你今晚誰地板吧！'); try {Thread.sleep(1000); } catch (InterruptedException e) {e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + 'myGirl：是你放手才對！'); synchronized (me) {// t1 , objB, 拿不到A鎖,等待System.out.println(Thread.currentThread().getName() + 'myGirl：看來你今晚要睡地板啊'); }} }}

先看看結果：

首先可以看到我們的進程還在運行狀態，但是都不往下運行代碼了，為什么呢，我們來分析來：

此時的狀態是線程1在執行第二個synchronized (myGirl) 這個同步代碼塊里中，還在等待me放手的時候，此時線程2又進來了，執行了第一個synchronized (me)這一個同步代碼塊中，相當于把me這個鎖鎖住了。

而線程1此時想進入第二個synchronized (me)的時候，發現這個me的鎖被人拿了就陷入等待狀態，而線程2發現要進入到第一個synchronized (myGirl) 中，myGirl又被線程1拿住了，也陷入了等待狀態。此時狀態就是兩個人在互相等待對方結束釋放鎖，陷入了無限等待的狀態。

而產生死鎖的必要條件有：

兩個或兩個以上的線程在執行過程中，因爭奪資源而造成了互相等待的狀態。

互斥條件：線程對于所分配到的資源具有排它性，即一個資源只能被一個線程占用，直到被該線程(進程)釋放。 請求與保持條件：一個線程因請求被占用資源而發生阻塞時，對已獲得的資源保持不放，即一個線程在已經有一個資源的資格后，又提出了新的資源請求。 不剝奪條件：線程已獲得的資源在末使用完之前不能被其他線程強行剝奪，只有自己使用完畢后才釋放資源。 循環等待條件：當發生死鎖時，所等待的線程必定會形成一個資源的環形鏈（類似于死循環），造成永久阻塞。總結

這篇文章就到這里了，如果這篇文章對你也有所幫助，希望您能多多關注好吧啦網的更多內容！