一个困扰了新手好几天的static小问题，怎么解释都不通，求助~~有代码

Question

一个有关死锁的小问题。主函数就没写了，就是搞不懂这里的Object o1和o2为什么要用static静态修饰，
o1,o2不就是两个对象的引用吗，没见过在创建对象及引用的时候，引用前面加static修饰的，看不懂这种格式，o1,o2在这里算什么成分呢......实在不懂，向大家求助了，先谢谢了。
public class TestDeadLock implements Runnable {
    public int flag = 1;
   static Object o1 = new Object();  
   static Object o2 = new Object();  
    public void run(){
     System.out.println("flag="+flag);
     if(flag==1){
     synchronized(o1){
      try{
      Thread.sleep(500);
       }catch(Exception ae){
       ae.printStackTrace();
       }
      synchronized(o2){
System.out.println("1");
}
       }
     }
     if(flag==0){
     synchronized(o2){
      try{
      Thread.sleep(500);
       }catch(Exception ae){
       ae.printStackTrace();
       }
      synchronized(o1){
System.out.println("0");
}
     }
    }
}
    

Answer 1

这样看不用加static也行，如果你在main函数里用，要加static，因为main函数是static类型的。

Answer 2

如果你创建多个TestDeadLock，o1静态修饰，所有的TestDeadLock对象能够对同一个o1同步，一个线程对象TestDeadLock访问o1时,其他线程对象等待。若不是静态的，就锁不了o1,每个TestDeadLock对象都有自己的对象锁，可能会有多个TestDeadLock对象同时对o1修改

Answer 3

如果不用static修饰 那么当你new多个线程的时候锁就也有好几把了不是原来的锁了

Answer 4

实际使用起来static和非static没啥区别，只不过static的对象内存中只存在一份，而非static的可能就多份了，如果只需要一份或者不需要多份那就可以使用static了

Answer 5

如果不用static修饰 那么当你new多个线程的时候锁就也有好几把了不是原来的锁了言简意赅，看懂了，初学者难啊

Answer 6

static 在前面加public 试一试

Answer 7

多个TestDeadLock 对象公用一个锁
所有才用static修饰
需要创建多个TestDeadLock对象才能看出效果 

Answer 8

static的话，你多次处理，都是同一个对象，如果不是Static的话，就会是多个，达不到测试锁想要的环境了，那就不算是个共享资源了

Answer 9

菜鸟路过，说两句，那个如果要达到死锁的目的，就应该是static修饰的吧，我不知道楼主是怎么测试的，这里我就楼主的代码做个完善，
public class TestDeadLock implements Runnable {
private int flag;
private static Object o1 = new Object();
private static Object o2 = new Object();
public TestDeadLock(int flag){
this.flag = flag;
}

public void run() {
System.out.println("flag=" + flag);
while (flag == 1) {
synchronized (o1) {
try {
Thread.sleep(500);
} catch (Exception ae) {
ae.printStackTrace();
}
synchronized (o2) {
System.out.println("1");
}
}
}
while (flag == 0) {
synchronized (o2) {
try {
Thread.sleep(500);
} catch (Exception ae) {
ae.printStackTrace();
}
synchronized (o1) {
System.out.println("0");
}
}
}
}
/**
 * 测试代码
 * @param args
 */
public static void main(String[] args) {
[code=java]new Thread(new TestDeadLock(0)).start();
new Thread(new TestDeadLock(1)).start();
}
}
[/code]
如果不用static修饰的话，那样测试时是达不到死锁的目的的，因为在开始线程的时候，
                new Thread(new TestDeadLock(0)).start();
new Thread(new TestDeadLock(1)).start();创建了两个new TestDeadLock(0)，new TestDeadLock(1)，如果没有用static这两个对象中的o1和o2是相互独立的，那么在同步代码块中执行时的两把锁是毫不相关的锁，不能达到等待的效果；而用了static后，不管你创建了多少个对象，o1和o2都只有一份，所以所有线程公用o1和o2两把锁，这样就能达到等待的效果。