这个死不了。帮忙看看啊
class Test implements Runnable
{
        Object obj1= new Object();
        Object obj2= new Object();
        private boolean flag;
        public Test(boolean flag)
        {
                this.flag = flag;
        }
        public void run()
        {
                if (flag)
                {
                        while(true)
                        {
                                synchronized(obj2)
                                {
                                        System.out.println("if lock222");
                                        synchronized(obj1)
                                        {
                                                System.out.println("if lock111");                                               
                                        }
                                }
                        }               
                }
                else
                {
                        while(true)
                        {
                                synchronized(obj1)
                                {
                                        System.out.println("lock1111");
                                        synchronized(obj2)
                                        {
                                                System.out.println("lock");
                                        }
                                }
                        }                       
                }
        }       
}
class myLooc
{
        static Object obj1 = new Object();
        static Object obj2 = new Object();
}
class day1116  
{
        public static void main(String[] args)
        {
                //Test t = new Test();
                Thread t1 = new Thread(new Test(true));
                Thread t2 = new Thread(new Test(false));
                t1.start();
                t2.start();
        }
}

没有发生死锁的原因呢是你 Thread t1 = new Thread(new Test(true))； Thread t2 = new Thread(new Test(false));这里的问题，new了两个Test对象，里面的obj自然不一样，我改了下代码，你可以看下

1. public static void main(String[] args)
   
2.         {
   
3.                 Test t = new Test(true);
   
4.                
   
5.                 Thread t1 = new Thread(t);
   
6.                 Thread t2 = new Thread(t);
   
7.                 t1.start();
   
8.                 try{Thread.sleep(20);}catch(Exception e){}
   
9.                 t.flag=false;
   
10.                 t2.start();
    
11.         }

复制代码

如果不加sleep好像是锁不住的，因为是在main的线程执行完t1.start()之后呢，还没等t1启动起来，就瞬间执行完了下面一句，将flag改为了false，因为就两个线程只执行else里面的语句，只输出lock
lock1111
lock
lock1111

明白了，锁出问题了

要想实现死锁，你的两个obj1必须是相同的对象，两个obj2也必须是相同的对象。
而你创建了两个线程，每个线程各new了一个Test对象，每个Test对象又各创建了一个obj1对象和obj2对象，这样你的两个线程用的锁就不是同一个对象了。
为了保证两个线程的obj1和obj2相同，可以使用你的myLooc类中的obj1和obj2。
把你Test类中的代码 Object obj1 = new Object();   Object obj2 = new Object();
改为：Object obj1 = myLooc.obj1;   Object obj2 = myLooc.obj2。这样就保证你用的是同一个obj1和obj2了，其它的代码不用变。

清风夜独醉 发表于 2014-4-16 20:41
要想实现死锁，你的两个obj1必须是相同的对象，两个obj2也必须是相同的对象。
而你创建了两个线程，每个线 ...

是这样的

不是同一个锁。

1.首先你并没有使用class myLooc中的静态属性 obj1, obj2   你在if语句和else语句中用的锁都  是class Test 的非静态属性 obj1  ,obj2
2. (1) if语句中的锁obj1和else语句中的锁0bj1不是同一把锁, (2) if语句中的锁obj2和else语句中的锁0bj2也不是同一把锁  ,也就是你使用了4把锁
3. 你在主方法中创建了Test类的两个对象,创建两个线程,每个线程只执行指定的代码,这一点没错,但是你使用的判断条件是不同的Test对象,
4,建议:给线程起个名字,根据名字来判断那个线程执行if语句,而在new线程时装入的Test对象只有一个