我自己写了个死锁代码，发现线程调用的时候用run锁不上，用start才锁得什么？怎么回事？

1. /*建立一个死锁范例
   
2. * 需求分析：1，首先要有多个线程
   
3. *                         2，应该有两个方法，分别互相嵌套加锁
   
4. *                         3,建立两把锁               
   
5. * */
   
6. class  synchronizedDemo
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 DeadDemo d1=new DeadDemo(true);
    
11.                 DeadDemo d2=new DeadDemo(false);
    
12.                 Thread t1=new Thread(d1);
    
13.                 Thread t2=new Thread(d2);
    
14. //                t1.start();
    
15. //                t2.start();
    
16.                 t1.run();
    
17.                 t2.run();
    
18.         }
    
19. }
    
20. 
    
21. class DeadDemo  implements Runnable
    
22. {
    
23.         //这里的flag要确保两个线程走不同的方法
    
24.         private boolean flag;
    
25.         //这里输入的不同值将确保线程访问不同的方法
    
26.         DeadDemo(boolean flag)
    
27.         {
    
28.                 this.flag=flag;
    
29.         }
    
30.         @Override
    
31.         public void run()
    
32.         {
    
33.                 while(true)
    
34.                 {
    
35.                         if(flag==true)
    
36.                         {
    
37.                                 synchronized (Lock.lockA)
    
38.                                 {
    
39.                                         System.out.println("if------lockA");
    
40.                                         synchronized (Lock.lockB)
    
41.                                         {
    
42.                                                 System.out.println("if------lockB");
    
43.                                         }
    
44.                                        
    
45.                                 }
    
46.                         }
    
47.                         else
    
48.                         {
    
49.                                 synchronized (Lock.lockB)
    
50.                                 {
    
51.                                         System.out.println("else------lockB");
    
52.                                         synchronized (Lock.lockA)
    
53.                                         {
    
54.                                                 System.out.println("else------lockA");
    
55.                                         }
    
56.                                 }
    
57.                         }
    
58.                 }
    
59.         }
    
60. 
    
61.         
    
62. }
    
63. //建立两把锁
    
64. class Lock
    
65. {
    
66.         public static  Lock  lockA=new Lock();
    
67.         public static  Lock  lockB=new Lock();
    
68. }
    

复制代码

大哥,run表示调用函数，start表示启动一个线程调用函数，现在明白了吗

何苦似梦离 发表于 2014-2-11 19:58
大哥,run表示调用函数，start表示启动一个线程调用函数，现在明白了吗

就这么简单？

你可以查API，看Thread类中这两个方法的具体说明