Java中多线程详解（2）产生死锁原因及解决方法

一、什么是死锁

死锁理解起来很简单，就是一个字，堵，下面图中拥堵的十字路口就可以看做一个死锁的状态，四个方向的车都要往前走，但是十字路口只有一个，只能允许一个方向的车通过后，才能让另一个方向的车通过。

在多线程中，四个方向的车流就可以看做4个线程，而十字路口可以看做一个资源对象，四个线程都要占有它，会导致程序无法正常的运行，这就叫死锁，是不是很容易理解呢。

用比较官方的解释死锁的话，就是经典的四大条件

1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。

4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

二、创建死锁案例

public class DeadLock {
    public static String r1="r1";
    public static String r2="r2";
    public static void main(String[] args) {
        Runable1 runable1=new Runable1();
        Runable2 runable2=new Runable2();
        Thread thread1=new Thread(runable1);
        Thread thread2=new Thread(runable2);
        thread1.start();
        thread2.start();
    }
}
class Runable1 implements Runnable{
    @Override
    public void run() {
        try {
             (DeadLock.r1) {
                System.out.println("r1的synchronized锁住r1");
                Thread.sleep(3000);
                synchronized (DeadLock.r2) {
                    System.out.println("拿不到r2略略略");
                    Thread.sleep(60 * 1000);
                }
                System.out.println("被锁住了，无法打印");
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Runable2 implements Runnable{
    @Override
    public void run() {
        try {
            synchronized (DeadLock.r2){
                System.out.println("synchronized锁住r2");
                Thread.sleep(3000);
                synchronized (DeadLock.r1){
                    System.out.println("拿不到r1略略略");
                    Thread.sleep(60 * 1000);
                }
                System.out.println("被锁住了，无法打印");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
//运行结果
r1的synchronized锁住r1
synchronized锁住r2

在上面这个案例中，先创建了两个资源对象r1和r2,然后创建了两个线程类Runable1和Runable2，用synchronized方法去给资源添加锁，使得两个线程在执行完run方法之前都不会释放资源对象r1和r2，（synchronized方法的作用就是一个同步锁，代码中放入synchronized括号中的资源在线程结束前都不会释放，也就不能被其他线程使用）之后用sleep方法让线程阻塞（sleep（3000）的作用是是给线程能锁住机会，sleep（60*1000）的作用是让线程阻塞），这样就造成了死锁的现象，导致后面的语句无法打印出来。

三、如何解决死锁问题

1.在写多线程操作时，最好不要一次锁定多个对象，这样就不会导致死锁了。修改后的代码如下。

public class DeadLock {
    public static String r1="r1";
    public static String r2="r2";
    public static void main(String[] args) {
        Runable1 runable1=new Runable1();
        Runable2 runable2=new Runable2();
        Thread thread1=new Thread(runable1);
        Thread thread2=new Thread(runable2);
        thread1.start();
        thread2.start();
    }
}
class Runable1 implements Runnable{
    @Override
    public void run() {
        try {
            synchronized (DeadLock.r1) {
                System.out.println("r1的synchronized锁住r1");
                Thread.sleep(3000);
                    System.out.println("拿到r2");
                    Thread.sleep(3000);
                System.out.println("解锁了，可以打印");
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Runable2 implements Runnable{
    @Override
    public void run() {
        try {
            synchronized (DeadLock.r2){
                System.out.println("synchronized锁住r2");
                Thread.sleep(3000); 
                   System.out.println("拿到r1");
                    Thread.sleep(3000);
                System.out.println("解锁了，可以打印");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
//运行结果
r1的synchronized锁住r1
synchronized锁住r2
拿到r2
拿到r1
解锁了，可以打印
解锁了，可以打印

 

2.如果业务场景需要一次锁定多个资源对象，可以根据资源的某个属性或者hashCode值来做比较，定义锁的先后顺序，下面是一个通过hashCode来定义锁先后顺序的例子。

public class DeadLock {
    public static String r1="r1";
    public static String r2="r2";
    public static void main(String[] args) {
        Runable1 runable1=new Runable1();
        Runable2 runable2=new Runable2();
        Thread thread1=new Thread(runable1);
        Thread thread2=new Thread(runable2);
        thread1.start();
        thread2.start();
    }
}
class Runable1 implements Runnable{
    @Override
    public void run() {
        try {
            if (DeadLock.r1.hashCode()>DeadLock.r2.hashCode()) {
                synchronized (DeadLock.r1) {
                    System.out.println("Runable1的synchronized锁住r1");
                    Thread.sleep(3000);
                    synchronized (DeadLock.r2) {
                        System.out.println("Runable1的synchronized锁住r2");
                        Thread.sleep(3000);
                    }
                    System.out.println("解锁了，可以打印");
                }
            }else{
                synchronized (DeadLock.r2) {
                    System.out.println("Runable1的synchronized锁住r1");
                    Thread.sleep(3000);
                    synchronized (DeadLock.r1) {
                        System.out.println("Runable1的synchronized锁住r2");
                        Thread.sleep(3000);
                    }
                    System.out.println("解锁了，可以打印");
                }
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Runable2 implements Runnable{
    @Override
    public void run() {
        try {
            if (DeadLock.r1.hashCode()<DeadLock.r2.hashCode()) {
                synchronized (DeadLock.r2) {
                    System.out.println("Runable2的synchronized锁住r2");
                    Thread.sleep(3000);
                    synchronized (DeadLock.r1) {
                        System.out.println("Runable2的synchronized锁住r1");
                        Thread.sleep(3000); 
                   }
                    System.out.println("解锁了，可以打印");
                }
            }else{
                synchronized (DeadLock.r1) {
                    System.out.println("Runable2的synchronized锁住r1");
                    Thread.sleep(3000);
                    synchronized (DeadLock.r2) {
                        System.out.println("Runable2的synchronized锁住r2");
                        Thread.sleep(3000);
                    }
                    System.out.println("解锁了，可以打印");
                }
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//运行结果
Runable1的synchronized锁住r1
Runable1的synchronized锁住r2
解锁了，可以打印
Runable2的synchronized锁住r1
Runable2的synchronized锁住r2
解锁了，可以打印