Lock类可以实现锁的功能，那么问题来了，synchronized可以指定锁对象，如果说Lock本身就是锁对象的话，在线程间通讯的时候，为什么使用同一个Lock对象lock两个方法内的代码，但这两个代码是可以同时执行的。

1. /*
   
2. 需求：演示Lock类和线程间通讯
   
3. */
   
4. 
   
5. import java.util.concurrent.locks.*;
   
6. 
   
7. //封装了主函数的类
   
8. class  ThreadDemo
   
9. {
   
10.         //主函数
    
11.         public static void main(String[] args)
    
12.         {
    
13.                 //创建Runnable子类对象，在构造函数中传入
    
14.                 Data data = new Data();
    
15. 
    
16.                 //创建两个线程对象，在构造函数传入同一个Runnable子类对象
    
17.                 new Thread(new TrueData(data)).start();
    
18.                 new Thread(new FalseData(data)).start();
    
19. 
    
20.         }
    
21. }
    
22. //用实现Runnable接口的方法创建类
    
23. class TrueData implements Runnable
    
24. {
    
25. 
    
26.         private Data data;
    
27. 
    
28.         TrueData(Data data)
    
29.         {
    
30.                 this.data = data;
    
31.         }
    
32.        
    
33.         public void run()
    
34.         {
    
35.                 data.on();
    
36.         }
    
37. }
    
38. //用实现Runnable接口的方法创建类
    
39. class FalseData implements Runnable
    
40. {
    
41.         private Data data;
    
42. 
    
43.         FalseData(Data data)
    
44.         {
    
45.                 this.data = data;
    
46.         }
    
47. 
    
48.         public void run()
    
49.         {
    
50.                 data.off();
    
51.         }
    
52. }
    
53. class Data
    
54. {
    
55.         private int num = 1;
    
56.         private boolean logic = true;
    
57. 
    
58.         //定义两个同步代码块的锁对象
    
59.         private Lock lock = new ReentrantLock();
    
60.         private Condition cona = lock.newCondition();
    
61.         private Condition conb = lock.newCondition();
    
62. 
    
63. 
    
64. 
    
65.         public void on()
    
66.         {
    
67.                 while(true)
    
68.                 {
    
69.                         try
    
70.                         {
    
71.                                 lock.lock();
    
72.                                 if (logic)
    
73.                                 {
    
74.                                         cona.await();
    
75.                                 }
    
76.                                 num = 1;
    
77.                                 logic = true;
    
78. 
    
79.                                 //打印语句
    
80.                                 System.out.println("Logic on..."+"num:"+num+" logic:"+logic);
    
81.                                                
    
82.                                 conb.signal();
    
83.                         }
    
84.                         catch (InterruptedException e)
    
85.                         {
    
86.                                 e.printStackTrace();
    
87.                         }
    
88.                         finally
    
89.                         {
    
90.                                 lock.unlock();
    
91.                         }
    
92.                 }
    
93.         }
    
94.         public void off()
    
95.         {
    
96.                 while(true)
    
97.                 {
    
98.                         try
    
99.                         {
    
100.                                 lock.lock();
     
101.                                         if(!logic)
     
102.                                                 conb.await();
     
103.                                         num = 0;
     
104.                                         logic=false;
     
105. 
     
106.                                         //打印语句
     
107.                                         System.out.println("Logic off......"+"num:"+num+" logic:"+logic);
     
108.                                                
     
109.                                         cona.signal();
     
110.                                
     
111.                         }
     
112.                         catch (InterruptedException e)
     
113.                         {
     
114.                                 e.printStackTrace();
     
115.                         }
     
116.                         finally
     
117.                         {
     
118.                                 lock.unlock();
     
119.                         }
     
120.                 }
     
121.         }
     
122. }
     

复制代码

像这样，线程在同步中wait了，为什么另一个线程可以执行同步内的代码，难道当前线程wait的时候会释放此锁么？看API中貌似没有这样的描述，困惑，请大神解答

Lock类可以实现锁的功能，那么问题来了，synchronized可以指定锁对象，如果说Lock本身就是锁对象的话，在线程间通讯的时候，为什么使用同一个Lock对象lock两个方法内的代码，但这两个代码是可以同时执行的。

1. /*
   
2. 需求：演示Lock类和线程间通讯
   
3. */
   
4. 
   
5. import java.util.concurrent.locks.*;
   
6. 
   
7. //封装了主函数的类
   
8. class  ThreadDemo
   
9. {
   
10.         //主函数
    
11.         public static void main(String[] args)
    
12.         {
    
13.                 //创建Runnable子类对象，在构造函数中传入
    
14.                 Data data = new Data();
    
15. 
    
16.                 //创建两个线程对象，在构造函数传入同一个Runnable子类对象
    
17.                 new Thread(new TrueData(data)).start();
    
18.                 new Thread(new FalseData(data)).start();
    
19. 
    
20.         }
    
21. }
    
22. //用实现Runnable接口的方法创建类
    
23. class TrueData implements Runnable
    
24. {
    
25. 
    
26.         private Data data;
    
27. 
    
28.         TrueData(Data data)
    
29.         {
    
30.                 this.data = data;
    
31.         }
    
32.        
    
33.         public void run()
    
34.         {
    
35.                 data.on();
    
36.         }
    
37. }
    
38. //用实现Runnable接口的方法创建类
    
39. class FalseData implements Runnable
    
40. {
    
41.         private Data data;
    
42. 
    
43.         FalseData(Data data)
    
44.         {
    
45.                 this.data = data;
    
46.         }
    
47. 
    
48.         public void run()
    
49.         {
    
50.                 data.off();
    
51.         }
    
52. }
    
53. class Data
    
54. {
    
55.         private int num = 1;
    
56.         private boolean logic = true;
    
57. 
    
58.         //定义两个同步代码块的锁对象
    
59.         private Lock lock = new ReentrantLock();
    
60.         private Condition cona = lock.newCondition();
    
61.         private Condition conb = lock.newCondition();
    
62. 
    
63. 
    
64. 
    
65.         public void on()
    
66.         {
    
67.                 while(true)
    
68.                 {
    
69.                         try
    
70.                         {
    
71.                                 lock.lock();
    
72.                                 if (logic)
    
73.                                 {
    
74.                                         cona.await();
    
75.                                 }
    
76.                                 num = 1;
    
77.                                 logic = true;
    
78. 
    
79.                                 //打印语句
    
80.                                 System.out.println("Logic on..."+"num:"+num+" logic:"+logic);
    
81.                                                
    
82.                                 conb.signal();
    
83.                         }
    
84.                         catch (InterruptedException e)
    
85.                         {
    
86.                                 e.printStackTrace();
    
87.                         }
    
88.                         finally
    
89.                         {
    
90.                                 lock.unlock();
    
91.                         }
    
92.                 }
    
93.         }
    
94.         public void off()
    
95.         {
    
96.                 while(true)
    
97.                 {
    
98.                         try
    
99.                         {
    
100.                                 lock.lock();
     
101.                                         if(!logic)
     
102.                                                 conb.await();
     
103.                                         num = 0;
     
104.                                         logic=false;
     
105. 
     
106.                                         //打印语句
     
107.                                         System.out.println("Logic off......"+"num:"+num+" logic:"+logic);
     
108.                                                
     
109.                                         cona.signal();
     
110.                                
     
111.                         }
     
112.                         catch (InterruptedException e)
     
113.                         {
     
114.                                 e.printStackTrace();
     
115.                         }
     
116.                         finally
     
117.                         {
     
118.                                 lock.unlock();
     
119.                         }
     
120.                 }
     
121.         }
     
122. }
     

复制代码

像这样，线程在同步中wait了，为什么另一个线程可以执行同步内的代码，难道当前线程wait的时候会释放此锁么？看API中貌似没有这样的描述，困惑，请大神解答