Java多线程产生死锁的一个简单案例

今天面试中 问到了Java多线程死锁的问题，回答不上来，特别囧，在网上查了查，结果如下

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3. 修改一个静态方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

首先，我们在java中创建两个字符串，strA 、strB。让每个线程都用synchronized锁住字符串（线程A先锁strA ，再去锁strB；线程B先锁strA，再锁strB），如果线程A锁住strA ，线程B锁住strB，线程A就没办法锁住strB，线程B也没办法锁住strA，这个时候就陷入了死锁。

package com.abcd;

public class Test {
    public static String objA = "strA";
    public static String objB = "strB";
    public static void main(String[] args){
        Thread a = new Thread(new Lock1());
        Thread b = new Thread(new Lock2());
        a.start();
        b.start();
    }    
}
class Lock1 implements Runnable{
    @Override
    public void run(){
        try{
            System.out.println("Lock1 running");
            while(true){
                synchronized(Test.objA){
                    System.out.println("Lock1 lock strA");
                    Thread.sleep(3000);//获取strA后先等一会儿，让Lock2有足够的时间锁住strB
                    synchronized(Test.objB){
                        System.out.println("Lock1 lock strB");
                    }
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
class Lock2 implements Runnable{
    @Override
    public void run(){
        try{
            System.out.println("Lock2 running");
            while(true){
                synchronized(Test.objB){
                    System.out.println("Lock2 lock strB");
                    Thread.sleep(3000);
                    synchronized(Test.objA){
                        System.out.println("Lock2 lock strA");
                    }
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

 那如何避免死锁呢？

要解决这个问题，使用资源排序的方法，即将需要锁的对象指定一个顺序，确保每个线程都按这个
顺序来获取锁。如下所示：

package com.abcd;

public class Test {
    public static String objA = "strA";
    public static String objB = "strB";
    public static void main(String[] args){
        Thread a = new Thread(new Lock1());
        Thread b = new Thread(new Lock2());
        a.start();
        b.start();
    }    
}
class Lock1 implements Runnable{
    @Override
    public void run(){
        try{
            System.out.println("Lock1 running");
            while(true){
                synchronized(Test.objA){
                    System.out.println("Lock1 lock strA");
                    Thread.sleep(3000);//获取strA后先等一会儿，让Lock2有足够的时间锁住strB
                    synchronized(Test.objB){
                        System.out.println("Lock1 lock strB");
                    }
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
class Lock2 implements Runnable{
    @Override
    public void run(){
        try{
            System.out.println("Lock2 running");
            while(true){
                synchronized(Test.objA){
                    System.out.println("Lock2 lock strA");
                    Thread.sleep(3000);
                    synchronized(Test.objB){
                        System.out.println("Lock2 lock strB");
                    }
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

现在不会有任何死锁，因为两个方法都以相同的顺序访问objA和objB的锁。因此，如果线程a获得了objA对象上的锁，则线程b将不会继续，直到线程a释放objA锁定为止，即使线程b持有ojbB锁，线程a也不会被阻塞，因为现在线程b不会期望线程a释放ojbA锁继续前进。