blocks|key|303627|text|除非您提供一些额外的代码，否则您无法区分这两者。例如，通过添加仅在notify()上设置为true的ThreadLocal+Boolean|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|303628|但首先，您必须确保您的逻辑需要这种区分。|303629|entityMap^0|X|8|19|4|1E|B|1Q|7|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

You can't differentiate between the two unless you provide some additional code. For example by adding a <code>ThreadLocal</code> <code>Boolean</code> that is set to <code>true</code> only on <code>notify()</code>

But first you must make sure your logic requires this differentiation.

blocks|key|3030166|text|异常不会在通知和超时时引发。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3030167|我认为与使用Object.wait()相比，使用java.lang.concurrent包同步对象更好。|offset|length|style|CODE|3030168|entityMap^0|0|6|D|O|K|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

Exception is not thrown on notify and time out.

I think it's better to rely on <code>java.lang.concurrent</code> package synchronisation objects instead of using <code>Object.wait()</code>.

blocks|key|298620|text|这并没有确切地回答这个问题，但它可能会解决您的问题:使用更高级别的并发机制。等待/通知通常比您想要的更低级，这是许多其他原因中的一个原因。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|298621|例如，如果您使用的是BlockingQueue.poll(long,+TimeUnit)，则可以检查结果是否为null，以了解是否超时。|offset|length|style|CODE|298622|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/BlockingQueue.html#poll%2528long,%2520java.util.concurrent.TimeUnit%2529^0|0|A|Y|A|Y|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]]|9|@$D|T|E|U|1|V]]|A|$]]|$1|H|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

This doesn't exactly answer the question, but it will probably solve your problem: Use higher level concurrency mechanisms. Wait/notify is usually more low-level than you'd want, for this reason among many others.

For example, if you were using <a href="http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/BlockingQueue.html#poll%28long,%20java.util.concurrent.TimeUnit%29" rel="noreferrer"><code>BlockingQueue.poll(long, TimeUnit)</code></a>, you could check if the result is null to know if you timed out.

blocks|key|298633|text|notify可以返回的另一个原因是:虚假唤醒。这不太可能，但却是可能的，因为在某些硬件/操作系统组合上，防止虚假唤醒是非常昂贵的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|298634|因此，您必须始终在循环中调用wait()，并重新检查您正在等待的条件。在这项工作中，很容易同时检查超时。|298635|有关详细信息，我推荐"Java并发实践“这本书。并使用更高级别的构造，这些构造将为您解决所有问题。|298636|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

There is one more reason that notify can return: spurious wakeup. This is an unlikely but possible thing, because preventing spurious wakeups is very expensive on some hardware/OS combinations.

Because of this you always have to call wait() in a loop and re-check the condition that you are waiting for. During this work it's easy to check for timeout at the same time.

For details I recommend the book "Java Concurrency In Practice". And using higher level constructs that will get this all correct for you.

blocks|key|3244421|text|没有办法直接告诉-也就是说，你必须添加额外的代码来确定这一点。通常，当您等待()时，您正在等待以某种方式改变对象状态的事情发生-例如，可能通过设置一个布尔变量。如果是这样，那么您可以简单地检查该变量的状态，以查看是否发生了事件，或者只是超时。或者，您可以查看System.currentTimeMillis()的值，以查看运行时间是否大于或等于超时时间-如果是，这可能是您已经超时的线索(尽管这不是绝对的保证)。或者，如果经过的时间小于超时时间，那么您肯定没有超时。这有帮助吗？|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3244422|entityMap^0|0|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

There's no way to tell directly - that is, you would have to add additional code to determine this. Often when you wait(), you're waiting for something to happen which changes the state of an object in some way - e.g. by setting a boolean variable, perhaps. If that's the case, then you may be able to simply check the state of that variable to see if the event occurred, or you merely timed out. Or you can look at the value of System.currentTimeMillis() to see i the elapsed time is greater than or equal to the timeout period - if it is, that would be a clue you have probably timed out (though it's not an absolute guarantee). Or if the elapsed time is less than the timeout period then you certainly have not timed out. Does that help?

blocks|key|301682|text|不要使用System.currentTimeMillis()，而要使用System.nanoTime()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|301683|第一个测量绝对时间(基于系统时钟)，如果系统时间改变，可能会产生奇怪的结果。例如:如果时钟向后移一小时，则5秒等待的持续时间可以为1小时，如果时钟向前移动，则10分钟等待将在0秒后完成。|301684|第二个是测量相对时间。它总是在一个方向上以恒定的速度运行，但它没有原点。这意味着这些值只能用来测量相对时间，但可以也不应该用来确定日期。|301685|entityMap^0|4|Q|Z|H|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

Don't use <code>System.currentTimeMillis()</code>, use <code>System.nanoTime()</code> instead. 

The first one meassures absolute time (based on system clock) and might have curious results if the system time is changed. For example: A 5 second wait can have a duration of an hour if the clock is moved backward by an hour, or a 10 minute wait will be done after 0 seconds if the clock is moved foreward.

The second one meassures relative time. It will always run in one direction at constant speed, but it has no origin. That means that the values can only be used to meassure relative time, but can and should not be used to determine a date.

blocks|key|303749|text|您应该使用not+wait/notify方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|303750|最好将锁与条件https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/Condition.html#await-long-java.util.concurrent.TimeUnit-一起使用|offset|length|303751|它具有await+with+timeout，如果在从方法返回之前经过了可检测到的等待时间，则将返回false，否则返回true|303752|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/Condition.html#await-long-java.util.concurrent.TimeUnit-^0|0|7|3H|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

You should use not wait/notify approach.

Will be better to use Lock with Condidions <a href="https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/Condition.html#await-long-java.util.concurrent.TimeUnit-" rel="nofollow noreferrer">https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/Condition.html#await-long-java.util.concurrent.TimeUnit-</a>

It has await with timeout and will return false if the waiting time detectably elapsed before return from the method, else true

Having this wait declaration:

<pre><code>public final native void wait(long timeout) throws InterruptedException;
</code></pre>

It could exit by InterruptedException, or by timeout, or because Notify/NotifyAll method was called in another thread, Exception is easy to catch but...

There is any way to know if the exits cause was timeout or notify?

EDIT:

This is a tricky way that could work, (although I don't like it)

<pre><code> long tBefore=System.currentTimeMillis();
 wait(TIMEOUT);
 if ((System.currentTimeMillis() - tBefore) &gt; TIMEOUT) 
 { 
 //timeout
 }
</code></pre>

How to differentiate when wait(long timeout) exit for notify or timeout?

Java

使用这个等待声明：public final native void wait(long timeout) throws InterruptedException;它可以通过InterruptedException退出，或者通过超时退出，或者因为Notify/NotifyAll方法是在另一个线程中调用的，所以异常很容易捕...

问如何区分等待(长超时)退出通知或超时？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何区分等待(长超时)退出通知或超时？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何区分等待(长超时)退出通知或超时？
EN