[已解决]关于java锁的问题

萌萌哒的小虎崽

Java中刚刚释放掉锁的线程在再次抢锁的速度上是不是会有优势啊？看这里的执行结果，一直都是两个线程连续执行两次，是巧合吗还是？

1. package com.dayuanit.lesson049;
   
2. 
   
3. public class testlesson049 {
   
4.        
   
5.         //false--说明篮子为空 true--说明篮子不为空
   
6.         public static boolean flag = false;
   
7.        
   
8.         public static Object lock = new Object();//定义一把全局使用的锁
   
9.        
   
10.         public static void main(String[] args) {
    
11.                 // TODO Auto-generated method stub
    
12.                
    
13.                 //生产者线程和消费者线程
    
14.                
    
15.                 Thread producerThread = new Thread(new ProducerThread(), "producer thread");
    
16.                 Thread customerThread = new Thread(new CustomerThread(), "customer thread");
    
17.                
    
18.                 producerThread.start();
    
19.                 customerThread.start();
    
20.         }
    
21. 
    
22. }
    
23. 
    
24. class ProducerThread  implements Runnable {
    
25.         public void run() {
    
26.                
    
27.                 //不停的进行生产消费
    
28.                 while (true) {
    
29.                         //需要先对全局的锁锁上，使用wait方法需要这一步，即释放这把锁
    
30.                         synchronized (testlesson049.lock) {
    
31.                                 //先进行一次判断，如果篮子是有东西的，作为生产者停止向篮子里装东西，等待消费者消费
    
32.                                 if (testlesson049.flag == true) {
    
33.                                        
    
34.                                         try {
    
35.                                                 System.out.println("篮子是满的，消费者快来消费啊！！");
    
36.                                                 System.out.println("-----------------------------");
    
37.                                                 testlesson049.lock.wait();//等待机制
    
38.                                         } catch (InterruptedException e) {
    
39.                                                 // TODO Auto-generated catch block
    
40.                                                 e.printStackTrace();
    
41.                                         }
    
42.                                 }
    
43.                                
    
44.                                 System.out.println("我是生产者，我能跑！！！");
    
45.                                
    
46.                                 //往篮子里装东西
    
47.                                 testlesson049.flag = true;
    
48.                                 System.out.println(testlesson049.flag);
    
49.                                 System.out.println("-----------------------------");
    
50.                                
    
51.                                
    
52.                                 //执行完毕后稍微休息一下
    
53.                                 try {
    
54.                                         Thread.sleep(2 * 1000);
    
55.                                 } catch (InterruptedException e) {
    
56.                                         // TODO Auto-generated catch block
    
57.                                         e.printStackTrace();
    
58.                                 }
    
59.                                 //告诉所有等待的线程，生产者的任务完成了
    
60.                                 testlesson049.lock.notifyAll();
    
61.                         }
    
62.                 }
    
63.         }
    
64. }
    
65. 
    
66. class CustomerThread  implements Runnable {
    
67.         public void run() {
    
68.                
    
69.                 //不停的进行生产消费
    
70.                 while (true) {
    
71.                         //需要先对全局的锁锁上，不然会出问题
    
72.                         synchronized (testlesson049.lock) {
    
73.                                 //先进行一次判断，如果篮子为空，作为消费者停止从篮子里取东西，等待生产者生产
    
74.                                 if (testlesson049.flag == false) {
    
75.                                         try {
    
76.                                                 System.out.println("篮子是空的，生产者快干活啊！！");
    
77.                                                 System.out.println("-----------------------------");
    
78.                                                 testlesson049.lock.wait();
    
79.                                         } catch (InterruptedException e) {
    
80.                                                 // TODO Auto-generated catch block
    
81.                                                 e.printStackTrace();
    
82.                                         }
    
83.                                 }
    
84.                                
    
85.                                 System.out.println("我是消费者，我拿到东西了！！！");
    
86.                                
    
87.                                 //从篮子里取走东西
    
88.                                 testlesson049.flag = false;
    
89.                                 System.out.println(testlesson049.flag);
    
90.                                 System.out.println("-----------------------------");
    
91.                                
    
92.                                 //执行完毕后稍微休息一下
    
93.                                 try {
    
94.                                         Thread.sleep(2 * 1000);
    
95.                                 } catch (InterruptedException e) {
    
96.                                         // TODO Auto-generated catch block
    
97.                                         e.printStackTrace();
    
98.                                 }
    
99.                                 //通知所有等待这把锁的线程，你们可以继续使用这把锁了
    
100.                                 testlesson049.lock.notifyAll();
     
101.                         }
     
102.                 }
     
103.         }
     
104.                
     
105.                
     
106. }
     

复制代码

最佳答案

月排行榜 / 总排行榜

倒戈卸甲

2020-4-20 14:22:25

萌萌哒的小虎崽 发表于 2020-4-20 14:13
那意思就是 生产者执行完毕以后，通知别人这把锁我不用了你们可以用的时候，这把锁的使用权还在它的手上 ...

。。。总觉得你的话哪里有点怪怪的感觉。但总体意思应该是没错的。唤醒其他线程的这个动作不会交出控制权。sleep或wait才会放开控制权

跳转到最佳答案楼层

倒戈卸甲

当然是你理解错了，生产者和消费者的代码都放在while循环里，即使执行到最后一行语句，即使执行到notifyAll，线程的操控权仍然在自己手里，马上开始下一次循环。交出去线程控制权一定是"notify别人且自己sleep了"，又或者执行到了wait语句

倒戈卸甲

再通俗的解释一下就是，唤醒你只是让你拥有和别人一样的排队权力，并不是你马上就能开饭了

萌萌哒的小虎崽

倒戈卸甲 发表于 2020-4-20 13:36
当然是你理解错了，生产者和消费者的代码都放在while循环里，即使执行到最后一行语句，即使执行到notifyAll ...

那意思就是 生产者执行完毕以后，通知别人这把锁我不用了你们可以用的时候，这把锁的使用权还在它的手上使得它能够再执行一次是吗？

倒戈卸甲

萌萌哒的小虎崽 发表于 2020-4-20 14:13
那意思就是 生产者执行完毕以后，通知别人这把锁我不用了你们可以用的时候，这把锁的使用权还在它的手上 ...

。。。总觉得你的话哪里有点怪怪的感觉。但总体意思应该是没错的。唤醒其他线程的这个动作不会交出控制权。sleep或wait才会放开控制权

萌萌哒的小虎崽

倒戈卸甲 发表于 2020-4-20 14:22
。。。总觉得你的话哪里有点怪怪的感觉。但总体意思应该是没错的。唤醒其他线程的这个动作不会交出控制权 ...

搜噶搜噶，我明白了，谢谢大佬~

zwhe