死锁和静态对象问题?

Question

如题所示, o1和o2申明为静态对象就可产生死锁,那非静态为什么不可以?
我所理解的静态对象：在内存空间只存在一份;
如果申明非静态是不是Lock lock1 = new Lock(1);Lock lock2 = new Lock(2);
lock1和lock2中都存在o1和o2?

public class Lock implements Runnable

private int flag;

public Lock(int flag) {
    this.flag = flag;
}

// **?**
static Object o1 = new Object();
static Object o2 = new Object();

public static void main(String[] args) {

    Lock lock1 = new Lock(1);
    Lock lock2 = new Lock(2);

    new Thread(lock1).start();
    new Thread(lock2).start();

}

public void run() {
    System.out.println("flag = " + flag);
    if (flag == 1) {
        synchronized (o1) {
            System.out.println("已持有O1 对象锁.");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2) {
                System.out.println("持有O2 对象锁");
            }
        }
    } else if (flag == 2) {
        synchronized (o2) {
            System.out.println("已持有O2 对象锁.");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1) {
                System.out.println("持有O1 对象锁");
            }
        }
    }
}

}

Answer 1

你最后说的是对的，如果非静态，lock1和lock2中都存在o1和o2，o1和o2分别有2份，是不同的对象。

静态成员变量，简单理解就是这个类所有对象都可以访问的全局变量，类加载的时候就会把这个对象创建出来。

Answer 2

静态 锁的是字节码 只有一份
非静态 锁的对象的成员变量 每一个对象不同，成员变量也不同 所以有多份

所以你最后说的是没问题的 非静态中的 lock1 lock2中都有各自的o1 o2