class deadTest implements Runnable{
        private int num=100;
        boolean fag=true;
        Object obj=new Object();
        public void run(){
                if(fag){
                while(true){
                        synchronized(obj){
                        show();
                                }
                        }
                }else{
                        while(true){
                                show();
                        }
                }
        }
        public synchronized void show(){
                synchronized(obj){
                if(num>0){
                        try{Thread.sleep(10);}catch(Exception e){}
        System.out.println(Thread.currentThread().getName()+"...."+num--);
                                }
                }
        }
}
public class 同步死锁 {
        public static void main(String[] args){
                deadTest d=new deadTest();
                Thread t=new Thread(d);
                Thread t1=new Thread(d);
                t.start();
                t1.start();
               
        }

}

class deadTest implements Runnable{
        private int num=1000;
        boolean fag=true;
        Object obj=new Object();
        public void run(){
                if(fag)
                {
                        while(true)
                        {
                        synchronized(obj)
                        {
                        show();
                        }
                    }
                }
                else
                {
                        while(true)
                        {
                                show();
                        }
                }
        }
        public synchronized void show()
        {
                synchronized(obj)
                {
                        if(num>0){
                        try{Thread.sleep(10);}catch(Exception e){}
        System.out.println(Thread.currentThread().getName()+"...."+num--);
                                }
                }
        }
}
public class 同步死锁
{
        public static void main(String[] args){
                deadTest d=new deadTest();
                Thread t=new Thread(d);
                Thread t1=new Thread(d);
                t.start();
                try{Thread.sleep(10);}catch(Exception e){}
                d.fag=false;
                t1.start();
               
        }

}
在主函数中加入t.start();
                try{Thread.sleep(10);}catch(Exception e){}
                d.fag=false;
                t1.start();
这样使线程在run方法中切换线程时可以实现死锁。

你的代码有点乱，fag至没有变过，if...else的else部分没有执行过。
要死锁必须是多个线程在没有释放自己的锁的时候想拿对方的锁。
这里说的锁更明确地说是锁上的监视器对象，你的程序中将Object obj作为监视器对象，但是两个线程中的
监视器对象是相同的（两个线程的Object obj是同一个），也就是说这里只有一个锁，两个线程抢来抢去都是同一个是不会死锁的。
虽然你把synchronized(obj)写了两边，但是里面的obj是同一个，谁拿到第一个也相当于拿到第二个。
这里你即使把两个obj换成两个也不会死锁，分析你的线程执行顺序，while（true）拿到第一个锁，进入show方法拿到第二个锁。两个锁的获得是顺序的不是并发的，换句话说拿到第一个锁的线程才有资格那第二个，该线程拿第二个锁没有人和他抢，这是不会死锁的，这基本上相当于是一个锁。
死锁很简单，让一个线程拿到锁1，等一会，第二个线程拿到锁2，等一下；两个线程再去拿对方的锁，必然会导致死锁的发生。

焦健 发表于 2012-12-12 22:22
class deadTest implements Runnable{
        private int num=1000;
        boolean fag=true;

不行啊？这样做还是能死锁啊？？

罗会涛 发表于 2012-12-12 22:29
你的代码有点乱，fag至没有变过，if...else的else部分没有执行过。
要死锁必须是多个线程在没有释放自己的 ...

能把我的代码写成死锁么？

魏冬 发表于 2012-12-12 23:44
不行啊？这样做还是能死锁啊？？

你把我贴的全部代码复制过去试试，可以的。我试过很多次才贴的，你多试试，我弄都是数值跑过好几百才锁住。

焦健 发表于 2012-12-12 23:56
你把我贴的全部代码复制过去试试，可以的。我试过很多次才贴的，你多试试，我弄都是数值跑过好几百才锁住 ...

嗯。先谢谢你了。我知道为什么不能死锁了。

魏冬 发表于 2012-12-12 23:46
能把我的代码写成死锁么？

1. class deadTest implements Runnable
   
2. {
   
3.         private int num = 100;
   
4.         boolean fag = true;
   
5.         static Object obj1 = new Object();//弄出两把锁，一把锁是不能死锁的
   
6.         static Object obj2 = new Object();
   
7. 
   
8.         public void run()
   
9.         {
   
10.                 if (fag)
    
11.                 {
    
12.                         synchronized (obj1)//拿锁1，拿完等一下对方拿另外一把锁2（不用sleep用while（true）多跑一下也是一样）
    
13.                         {
    
14.                                 try
    
15.                                 {
    
16.                                         Thread.sleep(10);
    
17.                                 }
    
18.                                 catch (Exception e)
    
19.                                 {
    
20.                                 }
    
21.                                 synchronized (obj2)//醒来拿锁2，对方这时候肯定拿到手了，再那肯定拿不到
    
22.                                 {
    
23.                                         show();
    
24.                                 }
    
25.                         }
    
26.                 }
    
27.                 else
    
28.                 {
    
29.                         synchronized (obj2)//拿锁2，拿完等一下对方拿另外一把锁1
    
30.                         {
    
31.                                 try
    
32.                                 {
    
33.                                         Thread.sleep(10);
    
34.                                 }
    
35.                                 catch (Exception e)
    
36.                                 {
    
37.                                 }
    
38.                                 synchronized (obj1)//醒来拿锁1，对方这时候肯定拿到手了，再那肯定拿不到
    
39.                                 {
    
40.                                         show();
    
41.                                 }
    
42.                         }
    
43.                 }
    
44.         }
    
45. 
    
46.         public synchronized void show()
    
47.         {
    
48.                 if (num > 0)
    
49.                 {
    
50.                         System.out.println(Thread.currentThread().getName() + "...."
    
51.                                         + num--);
    
52.                 }
    
53.         }
    
54. }
    
55. 
    
56. public class Test
    
57. {
    
58.         public static void main(String[] args)
    
59.         {
    
60.                 deadTest d = new deadTest();
    
61.                 d.fag = true;//用fag值控制两个线程开始的时候拿不同的锁
    
62.                 Thread t = new Thread(d);
    
63.                 d.fag = false;
    
64.                 Thread t1 = new Thread(d);
    
65.                 t.start();
    
66.                 t1.start();
    
67. 
    
68.         }
    
69. 
    
70. }

复制代码

明白死锁的概念应该很好写的啊