请高手写一个简单的死锁程序，并针对此程序提出几条解决方法：
程序：
写在这里。。。。。

解决方法：
1
2
3
4
    谢谢！

1. 03.package com.ljl.thread;  
   
2. 04.public class DealLock implements Runnable {  
   
3. 05.    private int flag = 1;  
   
4. 06.    // 此对象必须是静态的，同步必须是被多个线程共享  
   
5. 07.    static Object resource1 = new Object(), resource2 = new Object();  
   
6. 08.  
   
7. 09.    public void run() {  
   
8. 10.        if (flag == 1) {  
   
9. 11.            synchronized (resource1) {  
   
10. 12.                System.out.println("resource1");  
    
11. 13.                try {  
    
12. 14.                    Thread.sleep(1000);  
    
13. 15.                } catch (InterruptedException e) {  
    
14. 16.                    // TODO Auto-generated catch block  
    
15. 17.                    e.printStackTrace();  
    
16. 18.                }  
    
17. 19.                synchronized (resource2) {  
    
18. 20.                    System.out.println("resource2");  
    
19. 21.                }  
    
20. 22.            }  
    
21. 23.        }  
    
22. 24.        if (flag == 0) {  
    
23. 25.            synchronized (resource2) {  
    
24. 26.                System.out.println("resource2");  
    
25. 27.                try {  
    
26. 28.                    Thread.sleep(1000);  
    
27. 29.                } catch (InterruptedException e) {  
    
28. 30.                    // TODO Auto-generated catch block  
    
29. 31.                    e.printStackTrace();  
    
30. 32.                }  
    
31. 33.                synchronized (resource1) {  
    
32. 34.                    System.out.println("resource1");  
    
33. 35.                }  
    
34. 36.            }  
    
35. 37.        }  
    
36. 38.    }  
    
37. 39.  
    
38. 40.    public static void main(String[] args) {  
    
39. 41.        DealLock lock1 = new DealLock();  
    
40. 42.        DealLock lock2 = new DealLock();  
    
41. 43.        lock1.flag = 1;  
    
42. 44.        lock2.flag = 0;  
    
43. 45.        Thread ll1 = new Thread(lock1);  
    
44. 46.        Thread ll2 = new Thread(lock2);  
    
45. 47.        ll1.start();  
    
46. 48.        ll2.start();  
    
47. 49.    }  
    
48. 50.}  
    

复制代码

1. public class RunnableTest implements Runnable {
   
2.     private int flag = 1;
   
3.     private Object obj1 = new Object(), obj2 = new Object();
   
4. 
   
5.     public void run() {
   
6.         System.out.println("flag=" + flag);
   
7.         if (flag == 1) {
   
8.             synchronized (obj1) {
   
9.                 System.out.println("我已经锁定obj1，休息0.5秒后锁定obj2去！");   
   
10.                 try {
    
11.                     Thread.sleep(500);
    
12.                 } catch (InterruptedException e) {
    
13.                     e.printStackTrace();
    
14.                 }
    
15.                 synchronized (obj2) {
    
16.                     System.out.println("1");
    
17.                 }
    
18.             }
    
19.         }
    
20.         if (flag == 0) {
    
21.             synchronized (obj2) {
    
22.                 System.out.println("我已经锁定obj2，休息0.5秒后锁定obj1去！");   
    
23.                 try {
    
24.                     Thread.sleep(500);
    
25.                 } catch (InterruptedException e) {
    
26.                     e.printStackTrace();
    
27.                 }
    
28.                 synchronized (obj1) {
    
29.                     System.out.println("0");
    
30.                 }
    
31.             }
    
32.         }
    
33.     }
    
34. 
    
35.     public static void main(String[] args) {
    
36.         RunnableTest run01 = new RunnableTest();
    
37.         RunnableTest run02 = new RunnableTest();
    
38.         run01.flag = 1;
    
39.         run02.flag = 0;
    
40.         Thread thread01 = new Thread(run01);
    
41.         Thread thread02 = new Thread(run02);
    
42.         System.out.println("线程开始喽！");   
    
43.         thread01.start();
    
44.         thread02.start();
    
45.     }
    
46. }

复制代码

解决方法就是尽量不要在同步代码块中嵌套另一个同步代码块。