我的疑惑是，实现两个线程同步，必须要持有一个相同的对象吗，还有就是线程的等待和唤醒为什么要用他所持有的对象进行操作，能不能建一个本身对象然后进行操作。

1. public class Test{
   
2.         static int i = 1;
   
3.         public static void main(String[] args){
   
4.                 Object obj = new Object();
   
5.                 ThreadTwo t2 = new ThreadTwo(obj);
   
6.                 ThreadOne t1 = new ThreadOne(obj,t2);
   
7.                 t1.start();
   
8.         }
   
9. }
   
10. class ThreadOne extends Thread{
    
11.         private Object obj;
    
12.         private Thread t;
    
13.         public ThreadOne(Object obj,Thread t){
    
14.                 this.obj = obj;
    
15.                 this.t = t;
    
16.         }
    
17.         @Override
    
18.         public void run(){
    
19.                 synchronized(obj){
    
20.                         t.start();
    
21.                         while(true){
    
22.                                 Test.i--;
    
23.                                 System.out.println(Test.i);
    
24.                                 try{
    
25.                                         obj.wait();
    
26.                                 }catch(Exception e){
    
27.                                         e.printStackTrace();
    
28.                                 }
    
29.                                 obj.notify();
    
30.                         }
    
31.                 }
    
32.         }
    
33. }
    
34. class ThreadTwo extends Thread{
    
35.         private Object obj;
    
36. 
    
37.         public ThreadTwo(Object obj){
    
38.                 this.obj = obj;
    
39.         }
    
40.         @Override
    
41.         public void run(){
    
42.                 synchronized(obj){
    
43.                         while(true){
    
44.                                 Test.i++;
    
45.                                 System.out.println(Test.i);
    
46.                                 obj.notify();
    
47.                                 try{
    
48.                                         obj.wait();
    
49.                                 }catch(Exception e){
    
50.                                         e.printStackTrace();
    
51.                                 }
    
52.                         }
    
53.                 }
    
54.         }
    
55. }

复制代码

实现两个线程同步，是必须要持有一个相同的对象的。线程的同步其实就是个对资源的控制，一个线程访问了同步代码时，同步代码是锁住的，其他线程并不能访问。你可以将持有对象理解为一个锁，要访问同步代码必须要经过这把锁，你现在新建一个对象，对其进行操作相当于在开另一把锁，但是对于访问同步代码来说是没有意义的。