摘要：實(shí)現(xiàn)死鎖的方法有兩種，一種是使用同步代碼塊，另一種是使用重入鎖。但是如果調(diào)用帶超時(shí)的方法，那么如果線程在等待時(shí)被中斷，將拋出一個(gè)異常，這是一個(gè)非常有用的特性，因?yàn)樗试S程序打破死鎖。

思路：

死鎖是指在多線程環(huán)境下的這么一種場(chǎng)景，兩個(gè)（多個(gè)）線程在分別拿到自己的鎖時(shí)嘗試獲取對(duì)方的鎖，由于必須等待對(duì)方釋放鎖才能獲取，然而雙方誰(shuí)也不肯先釋放自己的鎖， 導(dǎo)致雙方誰(shuí)都無(wú)法繼續(xù)執(zhí)行。
通過(guò)一個(gè)實(shí)現(xiàn)runnable接口的類實(shí)例作為兩個(gè)線程的執(zhí)行對(duì)象，在該類中有兩個(gè)Object的靜態(tài)變量作為鎖.通過(guò)該類的一個(gè)開(kāi)關(guān)變量實(shí)現(xiàn)在同一個(gè)run方法中執(zhí)行兩段不同的邏輯，一個(gè)先獲取鎖1， 再獲取鎖2，另一個(gè)分支則剛好相反。
為了使第一個(gè)執(zhí)行的線程在拿到第二個(gè)鎖之前失去cpu執(zhí)行權(quán)，方便構(gòu)造死鎖場(chǎng)景，在嘗試獲取第二個(gè)鎖之前，讓線程休眠一段時(shí)間，因?yàn)閟leep()方法不會(huì)釋放鎖。
實(shí)現(xiàn)死鎖的方法有兩種，一種是使用synchronized同步代碼塊，另一種是使用reentrantlock重入鎖。
使用同步代碼塊實(shí)現(xiàn)死鎖
代碼

public class TestDeadLock implements Runnable {

//開(kāi)關(guān)
private boolean       flag;
//鎖1
private static Object lock1 = new Object();
//鎖2
private static Object lock2 = new Object();

public TestDeadLock(boolean flag) {
    this.flag = flag;
}

@Override
public void run() {
    if (flag) {
        synchronized (lock1) {
            System.out.println(flag + "線程拿到了lock1");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock2) {
                System.out.println(flag + "線程拿到了lock2");
            }
        }
    } else {
        synchronized (lock2) {
            System.out.println(flag + "線程拿到了lock2");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock1) {
                System.out.println(flag + "線程拿到了lock1");
            }
        }
    }
}

public static void main(String[] args) {
    Thread thread1 = new Thread(new TestDeadLock(true));
    Thread thread2 = new Thread(new TestDeadLock(false));
    thread1.start();
    thread2.start();
}

}
運(yùn)行結(jié)果

true線程拿到了lock1
false線程拿到了lock2
使用ReentrantLock實(shí)現(xiàn)死鎖
代碼

public class TestDeadLock2 implements Runnable{

private boolean flag;
private static ReentrantLock lock1=new ReentrantLock();
private static ReentrantLock lock2=new ReentrantLock();

public TestDeadLock2(boolean flag) {
    this.flag = flag;
}

@Override
public void run() {
    try {
        if(flag){
            lock1.lock();
            System.out.println(flag + "線程獲取了Lock1");
            TimeUnit.SECONDS.sleep(1);
            lock2.lock();
            System.out.println(flag+"線程獲取了Lock2");
        }else{
            lock2.lock();
            System.out.println(flag + "線程獲取了Lock2");
            TimeUnit.SECONDS.sleep(1);
            lock1.lock();
            System.out.println(flag+"線程獲取了Lock1");
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        if(lock1.isHeldByCurrentThread()){
            lock1.unlock();
        }
        if(lock2.isHeldByCurrentThread()){
            lock2.unlock();
        }
    }
}

public static void main(String[] args) throws InterruptedException {
    Thread thread1=new Thread(new TestDeadLock2(true));
    Thread thread2=new Thread(new TestDeadLock2(false));
    thread1.start();
    thread2.start();
    thread1.join();
    thread2.join();
    System.out.println("主線程已結(jié)束");
}

}
運(yùn)行結(jié)果

false線程獲取了Lock2
true線程獲取了Lock1
ReentrantLock和Synchronized的區(qū)別，具體可見(jiàn)
Java中的ReentrantLock和synchronized兩種鎖定機(jī)制的對(duì)比

。總的來(lái)說(shuō)，ReentrantLock所提供的功能比Synchronized要豐富的多，比如

lockInterruptibly
API簽名

public void lockInterruptibly() throws InterruptedException

代碼

public class TestDeadLock3 implements Runnable {

private boolean      flag;
static ReentrantLock lock1 = new ReentrantLock();
static ReentrantLock lock2 = new ReentrantLock();

public TestDeadLock3(boolean flag) {
    this.flag = flag;
}

@Override
public void run() {

    try {
        if (flag) {
            //可中斷地加鎖
            lock1.lockInterruptibly();
            System.out.println(flag + "線程獲取了lock1");
            TimeUnit.SECONDS.sleep(1);
            lock2.lockInterruptibly();
            System.out.println(flag + "線程獲取了lock2");
        } else {
            lock2.lockInterruptibly();
            System.out.println(flag + "線程獲取lock2");
            TimeUnit.SECONDS.sleep(1);
            lock1.lockInterruptibly();
            System.out.println(flag + "線程獲取了lock1");
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        if (lock1.isHeldByCurrentThread()) {
            lock1.unlock();
            System.out.println(flag + "線程釋放lock1鎖");
        }
        if (lock2.isHeldByCurrentThread()) {
            lock2.unlock();
            System.out.println(flag + "線程釋放lock2鎖");
        }
        System.out.println(flag + "線程已退出");
    }

}

public static void main(String[] args) throws InterruptedException {
    Thread thread1 = new Thread(new TestDeadLock3(true));
    Thread thread2 = new Thread(new TestDeadLock3(false));
    thread1.start();
    thread2.start();
    //主線程休眠5秒
    TimeUnit.SECONDS.sleep(5);
    thread1.interrupt();
}

}
運(yùn)行結(jié)果

true線程獲取了lock1
false線程獲取lock2
java.lang.InterruptedException

                                    at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:896)
                                    at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1221)
                                    at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:340)

true線程釋放lock1鎖

                                    at com.akane.test.reentrantlock.TestDeadLock3.run(TestDeadLock3.java:31)

true線程已退出

                                    at java.lang.Thread.run(Thread.java:744)

false線程獲取了lock1
false線程釋放lock1鎖
false線程釋放lock2鎖
false線程已退出

Process finished with exit code 0
關(guān)于interrupt的用法

synchronized在獲鎖的過(guò)程中是不能被中斷的，意思是說(shuō)如果產(chǎn)生了死鎖，則不可能被中斷（請(qǐng)參考后面的測(cè)試?yán)樱?。與synchronized功能相似的reentrantLock.lock()方法也是一樣，它也不可中斷的，即如果發(fā)生死鎖，那么reentrantLock.lock()方法無(wú)法終止，如果調(diào)用時(shí)被阻塞，則它一直阻塞到它獲取到鎖為止。但是如果調(diào)用帶超時(shí)的tryLock方法reentrantLock.tryLock(long timeout, TimeUnit unit)，那么如果線程在等待時(shí)被中斷，將拋出一個(gè)InterruptedException異常，這是一個(gè)非常有用的特性，因?yàn)樗试S程序打破死鎖。你也可以調(diào)用reentrantLock.lockInterruptibly()方法，它就相當(dāng)于一個(gè)超時(shí)設(shè)為無(wú)限的tryLock方法
主線程對(duì)Thread1進(jìn)行了中斷，thread1拋出異常，異常被捕獲，在finally中釋放thread1獲得的鎖，線程2獲得需要的鎖，該線程得以繼續(xù)執(zhí)行，死鎖就被解決了

tryLock
當(dāng)然，ReentrantLock還提供了另外一個(gè)更好的方法解決死鎖問(wèn)題，那就是使用tryLock()方法，該方法會(huì)嘗試獲得鎖，如果成功，返回true,失敗則返回false。該方法不等待或等待一段時(shí)間就返回。

API簽名

public boolean tryLock() 立即返回
public boolean tryLock(long timeout, TimeUnit unit) 等待一段時(shí)間后返回

死鎖的原因在于吃著碗里的看著鍋里的，我們讓線程拿到一個(gè)鎖之后無(wú)論是否拿到第二個(gè)鎖，都釋放已經(jīng)拿到的鎖，可以將此邏輯放入finally中，配合外層的while(true)多次重復(fù)嘗試，如果成功獲取兩個(gè)鎖，則釋放兩個(gè)鎖的同時(shí)推出while循環(huán)，以下是代碼實(shí)現(xiàn)，線程睡眠時(shí)間由1秒改為1毫秒，減少測(cè)試需要的時(shí)間

代碼

public class TestDeadLock4 implements Runnable{

private boolean      flag;
static ReentrantLock lock1 = new ReentrantLock();
static ReentrantLock lock2 = new ReentrantLock();
//統(tǒng)計(jì)發(fā)生死鎖的次數(shù)
private static int count;

public TestDeadLock4(boolean flag) {
    this.flag = flag;
}

@Override
public void run() {
    if(flag){
        while (true) {
            if(lock1.tryLock()){
                System.out.println(flag+"線程獲得了lock1");
                try {
                    TimeUnit.MILLISECONDS.sleep(1);
                    try {
                        if(lock2.tryLock()){
                            System.out.println(flag+"獲得了lock2");
                        }
                    } finally {
                        //同時(shí)獲得Lock1和lock2，沒(méi)有發(fā)生死鎖，任務(wù)完成，退出循環(huán)
                        if(lock1.isHeldByCurrentThread()&&lock2.isHeldByCurrentThread()){
                            System.out.println(flag+"線程執(zhí)行完畢"+"---------------------");
                            lock1.unlock();
                            lock2.unlock();
                            break;
                        }else{
                            //說(shuō)明發(fā)生了死鎖，只需要釋放lock1
                            count++;
                            System.out.println("發(fā)生了"+count+"次死鎖");
                            lock1.unlock();
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }else{
        while (true) {
            if(lock2.tryLock()){
                System.out.println(flag+"線程獲得了lock2");
                try {
                    TimeUnit.MILLISECONDS.sleep(1);
                    try {
                        if(lock1.tryLock()){
                            System.out.println(flag+"線程獲得了lock1");
                        }
                    } finally {
                        if(lock1.isHeldByCurrentThread()&&lock2.isHeldByCurrentThread()){
                            System.out.println(flag+"線程執(zhí)行完畢"+"---------------------");
                            lock1.unlock();
                            lock2.unlock();
                            break;
                        }else{
                            count++;
                            System.out.println("發(fā)生了"+count+"次死鎖");
                            lock2.unlock();
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public static void main(String[] args) throws InterruptedException {
    Thread thread1 = new Thread(new TestDeadLock4(true));
    Thread thread2 = new Thread(new TestDeadLock4(false));
    thread1.start();
    thread2.start();
}

}
運(yùn)行結(jié)果（部分）

全選復(fù)制放進(jìn)筆記true線程獲得了lock1
false線程獲得了lock2
發(fā)生了3358次死鎖
false獲得了lock1
false線程執(zhí)行完畢---------------------
true線程獲得了lock1
true獲得了lock2
true線程執(zhí)行完畢---------------------

Process finished with exit code 0
公平鎖
除此之外，ReentrantLock還有能實(shí)現(xiàn)線程公平獲取鎖的功能，所謂的公平，指的是在申請(qǐng)獲取鎖的隊(duì)列中，排在前面的線程總是優(yōu)先獲得需要的鎖，Synchronized同步獲得鎖的方式是非公平的，舉個(gè)例子，線程A和B都嘗試獲得C持有的鎖，當(dāng)C釋放該鎖時(shí)，A和B誰(shuí)能獲得該鎖是不確定的，也就是非公平的，而ReentrantLock提供公平地，即先來(lái)后到地獲取鎖的方式。