死锁知识总结

1.概念

两个或多个进程在执行的过程中，因为竞争资源而造成互相等待的现象

2.Demo

看下面的例子，对概念有个更加清晰的认识。

public class DeadLockDemo {

    public static void main(String[] args) {
        
        Object a = new Object();
        Object b = new Object();
        
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                synchronized (a) {
                    try {
                        System.out.println("Thread 1 started");
                        System.out.println("Got the lock of Object a");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Try to get the lock of Object b");
                    synchronized (b) {
                    }
                }
            }
        }).start();
        
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                synchronized (b) {
                    try {
                        System.out.println("Thread 2 started");
                        System.out.println("Got the lock of Object b");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Try to get the lock of Object a");
                    synchronized (a) {
                    }
                }
            }
        }).start();
    }
}

我们看代码，能立刻知道具体状况。可是，实际项目里，代码量巨大，运行时，我们如何排查呢？

3.死锁排查

3.1 Jconsole

 click 【Detect Deadlock】 button and then click【Deadlock】tab to check the Deadlock info.

3.2 jstack

 jps查询process id。然后根据id查询stack信息

 中间省略。。。

 至此，我们学到了如何排查死锁的问题，那么接下来，如何解决死锁的问题呢？

4.死锁产生的四个条件

①互斥量：锁

②自己占用一部分，同时想着占取别人拥有的部分。

③不可蛮力抢占对方的资源

④循环等待

拿最开始的代码的例子来说明。两个线程各自持有一个资源，同时想要拥有对方的资源，但是不能蛮力抢占，只能等到对方放开锁之后，才能去持有，这样就满足了上诉的四个条件，所以，产生了死锁。那么我们，怎么解决死锁的问题呢？

5.解决死锁

只要破坏上诉的任意一个条件即可。

1）使用定时的锁，指定超时时间timeout

public class DeadLockDemo {

    public static void main(String[] args) {
        
        ReentrantLock lock1 = new ReentrantLock();
        ReentrantLock lock2 = new ReentrantLock();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                lock1.tryLock();
                try {
                    System.out.println("Thread 1 started");
                    System.out.println("Thread 1 Got the lock1");
                    Thread.sleep(10000);
                    System.out.println("Thread 1 try to get the lock2");
                    if(lock2.tryLock(2, TimeUnit.SECONDS)) {
                        try {
                            System.out.println("Thread1 ： got lock1 and lock2 ...");
                        } finally {
                            lock2.unlock();
                        }
                    };
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock1.unlock();
                }
            }
        }).start();
        
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                lock2.tryLock();
                try {
                    System.out.println("Thread 2 started");
                    System.out.println("Thread 2 Got the lock2");
                    Thread.sleep(10000);
                    System.out.println("Thread 2 try to get the lock1");
                    if(lock1.tryLock(2, TimeUnit.SECONDS)) {
                        try {
                            System.out.println("Thread1 ： got lock1 and lock2 ...");
                        } finally {
                            lock1.unlock();
                        }
                    };
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock2.unlock();
                }
            }
        }).start();
    }

}

2）按照相同顺序来请求锁

public class DeadLockDemo {

    public static void main(String[] args) {
        
        Object a = new Object();
        Object b = new Object();
        
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                synchronized (a) {
                    try {
                        System.out.println("Thread 1 started");
                        System.out.println("Thread 1 Got the lock of Object a");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (b) {
                        System.out.println("Thread 1 Got the lock of Object b");
                    }
                }
            }
        }).start();
        
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                synchronized (a) {
                    try {
                        System.out.println("Thread 2 started");
                        System.out.println("Thread 2 Got the lock of Object a");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (b) {
                        System.out.println("Thread 2 Got the lock of Object a");
                    }
                }
            }
        }).start();
    }