第Java中死鎖與活鎖的具體實(shí)現(xiàn)目錄活鎖與死鎖活鎖死鎖死鎖的四個(gè)必要條件互斥條件請(qǐng)求和保持條件不剝奪條件環(huán)路等待條件死鎖示例死鎖排查總結(jié)一下如何避免死鎖預(yù)防死鎖設(shè)置加鎖順序活鎖示例解決活鎖

活鎖與死鎖

活鎖

活鎖同樣會(huì)發(fā)生在多個(gè)相互協(xié)作的線程間，當(dāng)他們?yōu)榱吮舜碎g的響應(yīng)而相互禮讓，使得沒(méi)有一個(gè)線程能夠繼續(xù)前進(jìn)，那么就發(fā)生了活鎖。同死鎖一樣，發(fā)生活鎖的線程無(wú)法繼續(xù)執(zhí)行。

相當(dāng)于兩個(gè)在半路相遇的人：出于禮貌他們相互禮讓，避開(kāi)對(duì)方的路，但是在另一條路上又相遇了。就這樣，不停地一直避讓下去。。。。

死鎖

兩個(gè)或更多線程阻塞著等待其它處于死鎖狀態(tài)的線程所持有的鎖。死鎖通常發(fā)生在多個(gè)線程同時(shí)但以不同的順序請(qǐng)求同一組鎖的時(shí)候，死鎖會(huì)讓你的程序掛起無(wú)法完成任務(wù)。

死鎖的四個(gè)必要條件

在Java中使用多線程，就會(huì)有可能導(dǎo)致死鎖問(wèn)題。死鎖會(huì)讓程序一直卡住，不再程序往下執(zhí)行。我們只能通過(guò)中止并重啟的方式來(lái)讓程序重新執(zhí)行。這是我們非常不愿意看到的一種現(xiàn)象，我們要盡可能避免死鎖的情況發(fā)生！

互斥條件

指進(jìn)程對(duì)所分配到的資源進(jìn)行排它性使用，即在一段時(shí)間內(nèi)某資源只由一個(gè)進(jìn)程占用。如果此時(shí)還有其它進(jìn)程請(qǐng)求資源，則請(qǐng)求者只能等待，直至占有資源的進(jìn)程用完釋放。

請(qǐng)求和保持條件

指進(jìn)程已經(jīng)保持至少一個(gè)資源，但又提出了新的資源請(qǐng)求，而該資源已被其它進(jìn)程占有，此時(shí)請(qǐng)求進(jìn)程阻塞，但又對(duì)自己已獲得的其它資源保持不放。

不剝奪條件

指進(jìn)程已獲得的資源，在未使用完之前，不能被剝奪，只能在使用完時(shí)由自己釋放。

環(huán)路等待條件

指在發(fā)生死鎖時(shí)，必然存在一個(gè)進(jìn)程資源的環(huán)形鏈，即進(jìn)程集合{A，B，C，，Z}中的A正在等待一個(gè)B占用的資源；B正在等待C占用的資源，，Z正在等待已被A占用的資源。

死鎖示例

/**@authorStrive*/

@SuppressWarnings("all")

publicclassDeadLockimplementsRunnable{

publicintflag=1;

/**面包*/

privatestaticfinalObjectbread=newObject();

/**水*/

privatestaticfinalObjectwater=newObject();

@Override

publicvoidrun(){

if(flag==1){

//先吃面包再喝水，環(huán)路等待條件

synchronized(bread){

try{

Thread.sleep(500);

}catch(Exceptione){

e.printStackTrace();

System.out.println("面包吃了，等喝水。。。");

synchronized(water){

System.out.println("面包吃了，水也喝到了");

if(flag==0){

//先喝水再吃面包，環(huán)路等待條件

synchronized(water){

try{

Thread.sleep(500);

}catch(Exceptione){

e.printStackTrace();

System.out.println("喝完水，等吃面包了。。。");

synchronized(bread){

System.out.println("喝完水，面包也吃完了。。。");

publicstaticvoidmain(String[]args){

DeadLocklockBread=newDeadLock();

DeadLocklockWater=newDeadLock();

lockBread.flag=1;

lockWater.flag=0;

//lockBread,lockWater都處于可執(zhí)行狀態(tài)，但JVM線程調(diào)度先執(zhí)行哪個(gè)線程是不確定的。

//lockWater的run()可能在lockBread的run()之前運(yùn)行

newThread(lockBread).start();

newThread(lockWater).start();

}

程序運(yùn)行結(jié)果：

喝完水，等吃面包了。。。

面包吃了，等喝水。。。

死鎖排查

先執(zhí)行上面的代碼，再進(jìn)行排查！

1、使用jps-l

D:\workspace-code\gitee\dolphinjps-l

7072org.jetbrains.jps.cmdline.Launcher

8824sun.tools.jps.Jps

17212

4012com.dolphin.thread.locks.DeadLock

6684org.jetbrains.idea.maven.server.RemoteMavenServer36

4012com.dolphin.thread.locks.DeadLock，粘貼進(jìn)程號(hào)4012

2、使用jstack4012

......

Javastackinformationforthethreadslistedabove:

===================================================

"Thread-1":

atcom.dolphin.thread.locks.DeadLock.run(DeadLock.java:40)

-waitingtolock0x000000076bf9e3d8(ajava.lang.Object)

-locked0x000000076bf9e3e8(ajava.lang.Object)

atjava.lang.Thread.run(Thread.java:748)

"Thread-0":

atcom.dolphin.thread.locks.DeadLock.run(DeadLock.java:26)

-waitingtolock0x000000076bf9e3e8(ajava.lang.Object)

-locked0x000000076bf9e3d8(ajava.lang.Object)

atjava.lang.Thread.run(Thread.java:748)

Found1deadlock.

從打印信息我們可以看出：

Found1deadlock：發(fā)現(xiàn)一個(gè)死鎖；Thread-1locked0x000000076bf9e3e8waitingtolock0x000000076bf9e3d8：線程1，鎖住了0x000000076bf9e3e8等待0x000000076bf9e3d8鎖；Thread-0locked0x000000076bf9e3d8waitingtolock0x000000076bf9e3e8：線程0，鎖住了0x000000076bf9e3d8等待0x000000076bf9e3e8鎖；

總結(jié)一下

當(dāng)DeadLock類的對(duì)象flag=1時(shí)（lockBread），先鎖定bread，睡眠500毫秒；而lockBread在睡眠的時(shí)候另一個(gè)flag==0的對(duì)象（lockWater）線程啟動(dòng)，先鎖定water，睡眠500毫秒；lockBread睡眠結(jié)束后需要鎖定water才能繼續(xù)執(zhí)行，而此時(shí)water已被lockWater鎖定；lockWater睡眠結(jié)束后需要鎖定bread才能繼續(xù)執(zhí)行，而此時(shí)bread已被lockBread鎖定；lockBread、lockWater相互等待，都需要得到對(duì)方鎖定的資源才能繼續(xù)執(zhí)行，從而死鎖；

如何避免死鎖

預(yù)防死鎖

其實(shí)就是破壞死鎖的四個(gè)必要條件！??！

破壞互斥條件：使資源同時(shí)訪問(wèn)而非互斥使用，就沒(méi)有進(jìn)程會(huì)阻塞在資源上，從而不發(fā)生死鎖。破壞請(qǐng)求和保持條件：采用靜態(tài)分配的方式，靜態(tài)分配的方式是指進(jìn)程必須在執(zhí)行之前就申請(qǐng)需要的全部資源，且直至所要的資源全部得到滿足后才開(kāi)始執(zhí)行，只要有一個(gè)資源得不到分配，也不給這個(gè)進(jìn)程分配其他的資源。破壞不剝奪條件：即當(dāng)某進(jìn)程獲得了部分資源，但得不到其它資源，則釋放已占有的資源，但是只適用于內(nèi)存和處理器資源。破壞循環(huán)等待條件：給系統(tǒng)的所有資源編號(hào)，規(guī)定進(jìn)程請(qǐng)求所需資源的順序必須按照資源的編號(hào)依次進(jìn)行。

設(shè)置加鎖順序

兩個(gè)線程試圖以不同的順序來(lái)獲得相同的鎖，如果按照相同的順序來(lái)請(qǐng)求鎖，那么就不會(huì)出現(xiàn)循環(huán)的加鎖依賴性，因此也就不會(huì)產(chǎn)生死鎖，每個(gè)需要鎖面包和鎖水的線程都以相同的順序來(lái)獲取面包和水，那么就不會(huì)發(fā)生死鎖了，如下圖所示：

根據(jù)上圖我們修改一下之前寫(xiě)的死鎖代碼，消除死鎖！

@Override

publicvoidrun(){

if(flag==1){

//先吃面包再喝水，環(huán)路等待條件

synchronized(bread){

try{

Thread.sleep(500);

}catch(Exceptione){

e.printStackTrace();

System.out.println("面包吃了，等喝水。。。");

synchronized(water){

System.out.println("面包吃了，水也喝到了");

if(flag==0){

//先喝水再吃面包，環(huán)路等待條件

synchronized(water){

try{

Thread.sleep(500);

}catch(Exceptione){

e.printStackTrace();

System.out.println("喝完水，等吃面包了。。。");

synchronized(bread){

System.out.println("喝完水，面包也吃完了。。。");

}

程序運(yùn)行結(jié)果：

喝完水，等吃面包了。。。

面包吃了，等喝水。。。

面包吃了，水也喝到了

喝完水，面包也吃完了。。。

這樣就可以消除死鎖發(fā)生~~~

活鎖示例

importjava.lang.management.ManagementFactory;

importjava.util.concurrent.ExecutorService;

importjava.util.concurrent.Executors;

importjava.util.concurrent.TimeUnit;

importjava.util.concurrent.locks.ReentrantLock;

/**@authorStrive*/

publicclassLiveLock{

staticReentrantLockbread=newReentrantLock();

staticReentrantLockwater=newReentrantLock();

publicstaticvoidmain(String[]args){

Stringname=ManagementFactory.getRuntimeMXBean().getName();

Stringpid=name.split("@")[0];

System.out.println("Pidis:"+pid);

System.out.println("jstack"+pid);

ExecutorServiceexecutorService=Executors.newCachedThreadPool();

executorService.submit(

()-{

try{

//嘗試獲得bread鎖

while(bread.tryLock(10,TimeUnit.SECONDS)){

System.out.println("拿到面包了，等著拿水。。。");

TimeUnit.SECONDS.sleep(1);

//判斷water是否被鎖住，如果鎖住，退出！再次嘗試獲取water鎖

booleanlocked=water.isLocked();

if(locked){

bread.unlock();

continue;

//嘗試獲得water鎖

booleanw=water.tryLock(10,TimeUnit.SECONDS);

//如果沒(méi)有獲取到water鎖，釋放bread鎖，再次嘗試！

if(!w){

bread.unlock();

continue;

System.out.println("拿到水了");

break;

System.out.println("吃面包，喝水！");

}catch(InterruptedExceptione){

System.out.println("線程中斷");

}finally{

water.unlock();

bread.unlock();

executorService.submit(

()-{

try{

while(water.tryLock(10,TimeUnit.SECONDS)){

System.out.println("拿到水了，等著拿面包。。。");

TimeUnit.SECONDS.sleep(2);

//判斷bread是否被鎖住，如果鎖住，退出！再次嘗試獲取bread鎖

booleanlocked=bread.isLocked();

if(locked){

water.unlock();

continue;

//嘗試獲得bread鎖

booleanb=bread.tryLock(10,TimeUnit.SECONDS);

//如果沒(méi)有獲取到bread鎖，釋放water鎖，再次嘗試！

if(!b){

water.unlock();

continue;

System.out.println("拿到面包了");

break;

System.out.println("喝水，吃面包！");

}catch(InterruptedExceptione){

System.out.println("線程中斷");

}finally{

bread.unlock();

water.unlock();

executorService.shutdown();

}

程序運(yùn)行結(jié)果：

Pidis:8788

jstack8788

拿到面包了，等著拿水。。。

拿到水了，等著拿面包。。。

拿到面包了，等著拿水。。。

拿到水了，等著拿面包。。。

拿到面包了，等著拿水。。。

拿到面包了，等著拿水。。。

拿到水了，等著拿面包。。。

已經(jīng)輸出打印了Pid，嘗試自己用jstack調(diào)試一下吧！可以參考如何排查死鎖的章節(jié)~

解決活鎖

鎖讓出的時(shí)候添加隨機(jī)睡眠時(shí)間

修改上面的程序，參考下面的代碼：

executorService.submit(

()-{

try{

//嘗試獲得bread鎖

while(bread.tryLock(10,TimeUnit.SECONDS)){

System.out.println("拿到面包了，等著拿水。。。");

TimeUnit.SECONDS.sleep(1);

//判斷water是否被鎖住，如果鎖住，退出！再次嘗試獲取water鎖

booleanlocked=water.isLocked();

if(locked){

bread.unlock();

//避免活鎖

TimeUnit.MILLISECONDS.sleep(1000);

continue;

//嘗試獲得water鎖

booleanw=water.tryLock(10,TimeUnit.SECONDS);

//如果沒(méi)有獲取到water鎖，釋放bread鎖，再次嘗試！

if(!w){

bread.unlock();

continue;

System.out.println("拿到水了");

break;

System.out.println("吃面包，喝水！");

}catch(InterruptedExceptione){

System.out.println("線程中斷");

}finally{

water.unlock();

bread.unlock();

executorService.submit(

()-{

try{

whil