141 | 同步控制之wait notify-零基础学Java-极客时间

老师您好有一个问题不是很清楚，希望能帮我解答一下。既然说synchronized是不公平锁，那么对于这个样例程序里除了main以外的五个线程，4s左右，第二个thread结束sleep准备调用wait方法时，此时，main thread应该已经结束了3s的sleep，运行到notify的synchronized代码块，所以main thread 应该要和剩下的其余3个thread一起争抢locker的monitor，所以应该有可能出现main thread先抢到locker的monitor的情况，导致程序运行出错，但是我试了几次发现，程序总是在5个子线程都抢到locker的monitor之后，main thread才能拿到locker的monitor依次唤醒5个子线程，这是为什么呢？

作者回复: 是这样的，synchronized不保证（强调不保证）是公平锁。但是并不代表实际在某个具体程序的某次运行时，他的表现是和公平锁一样的。只要有不公平的可能，就不能说是公平锁。要能百分之百保证在任何情况下都是公平锁，代价很高。synchronized是随缘公平，不保证公平。

2019-10-11

2

9

蓦然回首

再发一下notify的总结: 1、notify使用的前提: 调用notify的线程必须拥有指定object的monitor(锁) This method should only be called by a thread that is the owner of this object's monitor. 2、notify的作用: 唤醒正在指定object wait的单个线程。如果有多个线程在该对象上等待，则选择其中一个唤醒。该选择是任意的，并且可以根据实现来决定。当前线程放指定object的monitor(锁)之前，被唤醒的线程将无法继续。被唤醒的线程将和任何需要获得指定object的monitor(锁)的线程竞争。被唤醒的线程在作为获得指定object的monitor(锁)的下一个线程时没有任何优势。

作者回复: 赞！

2020-11-18



4

song

老师，需要保证在所有线程进入wait之后进行notify唤醒，代码里面sleep了3秒可以达到这个目的，这个想了好久。我的理解是：主线程的locker.notifyAll()会跟其他5个线程locker.wait()同时抢锁 Object locker，由于主线程 sleepSec(workingSec + 1); 大于其他5个线程的 sleepSec(workingSec);，同时由于locker锁对象是共享的，所以会导致锁最开始被其他5个线程抢到，直到5个线程都进入wait后，被释放的锁才被主线程抢到，最终保证了notifyAll在所有进入wait之后进行。这样理解正确吗？

作者回复: 从程序设计和主管感觉上，是的。但是这相当于是创造了一种比较理想的条件，让主线程排在worker的后面。为什么呢？后面也会讲到，synchronized不是公平锁，也就是说，是不保证先来先得的。重点词：不保证。不保证的意思是说，不在保证锁的公平性上，花费太多的代价。但是就我们这个例子来说，主线程因为多sleep了一秒钟，其实并不是一个非常严格的竞争环境，所以除非非常小的几率，否则主线程都还会排在worker线程后面拿到锁。

2020-05-04



3

蓦然回首

老师，花了点时间把javadoc上面关于wait和notify的相关文档看了一下，算是彻底搞明白它们的执行流程,大概整理了一下，老师看看我总结的是否正确: 1、wait使用的前提: The current thread must own this object's monitor lock 调用wait的线程必须拥有指定object的monitor(锁) (在视频中代码，即为在synchronized (locker)代码块中) 2、wait的作用: 调用wait的线程被加入指定object的wait集合中，并且放弃在指定object上的同步声明 (即失去指定object的monitor(锁)，即会解锁，) This method causes the current thread (referred to here as <var>T</var>) to place itself in the wait set for this object and then to relinquish any and all synchronization claims on this object. (但仅仅是会失去指定object的monitor(锁)，对于其他可能存在的锁没影响) Note that only the locks on this object are relinquished; any other objects on which the current thread may be synchronized remain locked while the thread waits. wait期间，线程调度不可用，线程处于休眠状态 Thread T then becomes disabled for thread scheduling purposes 3、线程调用wait后，再次被唤醒的条件: 1)其他线程使用指定object调用notify,并且该线程碰巧被作为随机选择的线程去被唤醒 2)其他线程使用指定object调用notifyAll 3)其他线程interrupts该线程 4)指定的超时时间过去了(wait指定了超时时间，如locker.wait(1000)) 当超时时间为0时，超时时间被忽略，线程会一直休眠直到因为上面三种因素被唤醒 5)线程被虚假唤醒(线程可以在没有通知、中断或超时的情况下被唤醒，这就是所谓的假唤醒) 4、线程被唤醒后的执行流程: 然后当线程被唤醒时，将从指定object对象的等待集合中删除，并重新开启线程调度。此时，它将再次与其他线程竞争指定object对象的monitor(锁) ，一旦它重新获得了对对象的指定object对象的monitor(锁) ,线程将恢复到调用wait方法时的状态，然后线程从wait方法的调用中返回 5、虚假唤醒的解决方案: 因为存在假唤醒，虽然这种情况在实践中很少发生，但应用程序必须通过测试导致线程被唤醒的条件来防止这种情况发生，如果条件不满足，则继续等待。如下示例: synchronized (locker) { while (<condition does not hold> and <timeout not exceeded>) { long timeoutMillis = ... ; // recompute timeout values int nanos = ... ; obj.wait(timeoutMillis, nanos); } ... // Perform action appropriate to condition or timeout }

作者回复: 很好很全面

2020-11-18



2

jjn0703

请教一下老师，有个需求是去先走第三方接口拉取数据回来实时计算，但是有时候数据会过多，要求是最多拉十秒的数据，请问这个该怎么实现呀

作者回复: 这个接口如果是http的话，需要自己做一些控制。http本身并没有拉取数据过多导致超时这么个设置，只能说是连不上之类的网络问题导致timeout。从我理解你的需求来看，即使拉取的数据超过10秒，其实也是在正常传输数据的，http自己不会因为这个断掉。我的理解是，你这边的程序有个DataPuller，按照主程序的需求，向第三方发起http请求，拉取数据，然后主程序等待DataPuller返回数据，但是最多只想等待10秒，10秒内能结束最好，不能结束就有多少数据就给主程序多少就行了。下面的示例代码供你参考： https://gist.github.com/deepnighttwo/b760bf0bbaddaaf3d3fb6e331684b54d /** * @author 臧萌 */ public class PullDataWithTimeLimitAppMain { public static void main(String[] args) throws InterruptedException { long start = System.currentTimeMillis(); CountDownLatch countDownLatch = new CountDownLatch(1); PullDataTask task = new PullDataTask(countDownLatch); new Thread(task).start(); System.out.println("Waiting for data pulling"); countDownLatch.await(10, TimeUnit.SECONDS); System.out.println("Finished waiting. Actually waited for " + (System.currentTimeMillis() - start) / 1000 + " sec. Data got from data puller is " + task.getDataList()); } } class PullDataTask implements Runnable { private List<Integer> dataList = new ArrayList<>(); private CountDownLatch countDownLatch; public PullDataTask(CountDownLatch countDownLatch) { this.countDownLatch = countDownLatch; } @Override public void run() { int timeSec = (int) (Math.random() * 20); System.out.println("going to pulling data for " + timeSec + " seconds"); IntStream.range(0, timeSec).forEach(i -> { try { Thread.sleep(TimeUnit.SECONDS.toMillis(1)); } catch (InterruptedException e) { e.printStackTrace(); } dataList.add(i); }); countDownLatch.countDown(); System.out.println("pulling finished"); } public List<Integer> getDataList() { return dataList; } }

2020-03-21



2

我的名字叫楠哥

学到线程的时候。就开始完全懵了😂

作者回复: 我学的时候可能比你还懵。多写，用心去感受：线程是执行代码的。代码是告诉线程执行的命令的

2022-04-12



1

笨笨

老师唤醒线程的优先级是最低的吗？为什么它是最后一个抢到锁的？

作者回复: 这个和线程的优先级是没关系的。这个例子里，notify线程是最后一个去抢锁的。我们可以假想所有抢锁的线程都在一个队列里等着，那么最后一个抢的，大概率会最后一个抢到。当然Java语言和Java规范并没有这样规定。

2021-01-16



1

笨笨

new Thread(() -> { System.out.println(getName() + ":线程开始工作....."); try { synchronized (locker) { sleepSec(workingSec); System.out.println(getName() + "：进入等待"); locker.wait(); System.out.println(getName() + ":线程继续...."); sleepSec(2); System.out.println(getName() + ":结束"); } } catch (InterruptedException e) { e.printStackTrace(); } }, "工作线程" + i).start();老师这段代码中的( () -> {} )进行了什么操作呢？

作者回复: () -> {} 就是lambda的表达式，也就是Thread执行的实际代码。这个代码里面就是用sleep模拟工作，用locker去模拟获取不可共享的资源。

2020-11-29



1

蓦然回首

不过，文档中好像没有明确说明， notify和notifyAll本身是否会类似于wait一样，执行完之后就立马解锁了，然后再和其他线程一起来重新抢占，不然单独notify就没办法理解了，因为一直如果没解锁，locker本身一直被notify(notifyAll)的线程占有着，其他wait的线程根本没机会获取到锁,这个地方希望说明一下

作者回复: notify不会释放锁，notify本身是在synchronized里的，synchronized块结束就会释放锁。

2020-11-18

2

1

蓦然回首

另外线程能拥有指定object对象的monitor(锁)，有三种方式（即synchronized作用在类的三种方式）: 1)作用在类成员方法,即指定object对象的monitor(对象锁) 2)作用于类的静态成员方法上，指定类的类型锁(类锁) 3)作用于类的静态成员方法上，指定类的类型锁(类锁)

作者回复: 本质是一样的，对象上的锁。

2020-11-18



1

收起评论