class Test2 implements Runnable
{
       
        private boolean flag;       

        Test2(boolean flag)
        {
                this.flag = flag;
                }
        public void run()
        {
                if(flag)
                {
                        while(true)
                        {
                        synchronized(MyLock.locka)
                        {
                                System.out.println("if locka");
                                synchronized(MyLock.lockb)
                                {
                                        System.out.println("if lockb");
                                }
                        }
                        }
                }
                else
                {
                        while(true)
                        {
                        synchronized(MyLock.lockb)
                        {
                                System.out.println("else lockb");
                                synchronized(MyLock.locka)
                                {
                                        System.out.println("else locka");
                                }
                        }
                        }
                }
        }
}
class MyLock
{
        static Object locka = new Object();
        static Object lockb = new Object();
       
}
public class DeadLock {
        public static void main(String[] args)
        {
               
                Thread t1 = new Thread(new Test2(true));
                Thread t2 = new Thread(new Test2(false));
                t1.start();
                t2.start();
        }
}
除类中定义MyLock类，如何使用对象级别实现死锁？？？？？？？求代码

我看到有个总结好简单的，看这下。

1. synchronized(a){  
   
2.        ...//1  
   
3.         synchronized(b){  
   
4.    
   
5.        }  
   
6. }  
   
7.    
   
8. synchronized(b){  
   
9.        ...//2  
   
10.        synchronized(a){  
    
11.    
    
12.        }  
    
13. }  

复制代码

你可以试试这个；我只是是定义了两个String对象，对他们用锁也可死锁。其他的没有试过。

1. /*
   
2. * 线程死锁的测试
   
3. * 需求：写出一个会造成死锁的多线程。
   
4. * 方案：当线程1锁定了resource1时，再去试图锁定resource2.(此时，线程2可能锁定了resource2)
   
5. *                 当线程2锁定了resource2时，再去试图锁定resource1.(此时，线程1可能锁定了resource1)
   
6. * 1两个线程类。继承Runnable接口。
   
7. * 2构造函数，接收两个资源：resource1 处resource2
   
8. * 3并实现其run方法。并且方法内执行对两个资源同步锁：synchronized
   
9. * 4为体现效果，让线程休眠若干秒。
   
10. */
    
11. class TestDeadThread {
    
12.         public static void main(String[] args) {
    
13.                  String resource1 = "resource1";
    
14.                  String resource2 = "resource2";
    
15. 
    
16.                 Thread thread1 = new Thread(new Thread1(resource1, resource2));
    
17.                 Thread thread2 = new Thread(new Thread2(resource1, resource2));
    
18.                 thread1.start();
    
19.                 thread2.start();
    
20. 
    
21.         }
    
22. }
    
23. 
    
24. /*
    
25. * 线程1
    
26. */
    
27. class Thread1 implements Runnable {
    
28.         String resource1;
    
29.         String resource2;
    
30. 
    
31.         Thread1(String r1, String r2) {
    
32.                 resource1 = r1;
    
33.                 resource2 = r2;
    
34.         }
    
35. 
    
36.         @Override
    
37.         public void run() {
    
38.                 //
    
39.                 synchronized (resource1) {
    
40.                         System.out.println("1锁住resource1===");
    
41.                         synchronized (resource2) {//锁定resource1的同时，试图要锁定resource2
    
42.                                
    
43.                                         while(true){
    
44.                                                 System.out.println("1锁住resource2");
    
45.                                        
    
46.                                         try {
    
47.                                                 Thread.sleep(100);
    
48.                                         } catch (InterruptedException e) {
    
49.                                                 e.printStackTrace();
    
50.                                         }
    
51.                                 }
    
52.                         }
    
53.                 }
    
54.         }
    
55. 
    
56. }
    
57. 
    
58. /*
    
59. * 线程2
    
60. */
    
61. class Thread2 implements Runnable {
    
62.         String resource1;
    
63.         String resource2;
    
64. 
    
65.         Thread2(String r1, String r2) {
    
66.                 resource1 = r1;
    
67.                 resource2 = r2;
    
68.         }
    
69. 
    
70.         @Override
    
71.         public void run() {
    
72.                 //
    
73.                 synchronized (resource2) {
    
74.                         System.out.println("2锁住resource2");
    
75.                         synchronized (resource1) {//锁定resource2的同时，试图要锁定resource1
    
76.                                 System.out.println("2锁住resource1===");
    
77.                         }
    
78.                 }
    
79. 
    
80.         }
    
81. 
    
82. }

复制代码

多谢了！

class A extends Thread
{
        public void run(){
                synchronized(A.class){
                        try{Thread.sleep(10);}catch(Exception e){}
                        synchronized(B.class){
               
                        }
                }
        }
}
class B extends Thread
{
        public void run(){
                synchronized(B.class){
                        try{Thread.sleep(10);}catch(Exception e){}
                        synchronized(A.class){
               
                        }
                }
        }
}
public class ThreadDemo
{
        public static void main(String[] args){
                A a = new A() ;
                B b = new B() ;

                a.start() ;
                b.start() ;
        }
}
这是一个最简单死锁，其实编写死锁代码只会出现在面试中，没有哪个程序员会在项目中故意写个死锁，那是自找麻烦，所以以后我们应该避免死锁，死锁只需要理解原理就行。。。。