1. /*
   
2. 创建一个测试类，里面有两个A类对象，然后建立两个线程，分别给线程的构造器传参数
   
3. th1(sj1,sj2),th2(sj2,sj1),再创建一个测试类，然后启动两个线程
   
4. */
   
5. public class DieLockTest {
   
6.         public static void main(String[] args) {
   
7.                 ShuJu sj1=new ShuJu();
   
8.                 ShuJu sj2=new ShuJu();
   
9.                 Thread th1=new ThreadTest(sj1,sj2);
   
10.                 Thread th2=new ThreadTest(sj2,sj1);
    
11.                 th1.start();
    
12.                 th2.start();
    
13.                 }
    
14. 
    
15. }
    
16. //创建一个线程类，有两个属性，为A类属性，为线程类构造器传参数
    
17. //重写run（）方法，然后里面有一个A类的引用调用fun1（），参数为A类
    
18. //对象
    
19. class ThreadTest extends Thread{
    
20.         private ShuJu sj1;
    
21.         private ShuJu sj2;
    
22.         public ThreadTest(ShuJu sj1,ShuJu sj2){
    
23.                 this.sj1=sj1;
    
24.                 this.sj2=sj2;
    
25.         }
    
26.         public void run(){
    
27.                 sj1.fun1(sj2);
    
28.         }
    
29. }
    
30. //定义一个数据类，里面有两个同步方法，为了实现死锁，让一个方法的参数为本类类型
    
31. //然后为了使效果明显一些，我们使线程sleep一会
    
32. 
    
33. class ShuJu{
    
34.         public synchronized void fun1(ShuJu sj){
    
35.                 String str=Thread.currentThread().getName();
    
36.                 System.out.println(str+"  "+"準備死鎖");
    
37.                 try {
    
38.                         Thread.sleep(1000);
    
39.                 } catch (InterruptedException e) {
    
40.                        
    
41.                 }
    
42.                 sj.fun2();
    
43.                
    
44.         }
    
45.         public synchronized void fun2(){}
    
46. }

复制代码

值得学习ing!