Why does java.util.concurrent.ArrayBlockingQueue use ‘while’ loops instead of ‘if’ around calls to await()?

by

To protect against spurious wake ups. There is no guarantee made to you by the JVM that the only possible reason the thread will ever start running again is because you called signal in the way you intended. Sometimes it will just get started accidentally and go (Spurious wake up). So you have to keep waiting again if the condition you want to run on isn’t actually true.

This is explained in the javadoc for the wait method:
http://java.sun.com/javase/6/docs/api/java/lang/Object.html#wait%28long%29

And mentioned in the docs for await:
http://java.sun.com/javase/6/docs/api/java/util/concurrent/locks/Condition.html#await%28%29

The lock associated with this
Condition is atomically released and
the current thread becomes disabled
for thread scheduling purposes and
lies dormant until one of four things
happens:

  • Some other thread invokes the signal() method for this Condition and
    the current thread happens to be
    chosen as the thread to be awakened;
    or

  • Some other thread invokes the signalAll() method for this Condition;
    or

  • Some other thread interrupts the current thread, and interruption of
    thread suspension is supported; or

* A “spurious wakeup” occurs.

Some implementations of the Condition interface may suppress spurious wakeups, but relying on that would hence be relying on an implementation detail and makes your code unportable.

More Related Contents:

  1. What’s the difference between Thread start() and Runnable run()
  2. Why is creating a Thread said to be expensive?
  3. Why is i++ not atomic?
  4. Synchronization vs Lock
  5. Java Wait and Notify: IllegalMonitorStateException
  6. Are static variables shared between threads?
  7. Prime numbers by Eratosthenes quicker sequential than concurrently?
  8. Is iterating ConcurrentHashMap values thread safe?
  9. How to solve the “Double-Checked Locking is Broken” Declaration in Java?
  10. Executors.newCachedThreadPool() versus Executors.newFixedThreadPool()
  11. Is it safe to get values from a java.util.HashMap from multiple threads (no modification)?
  12. What’s a monitor in Java?
  13. Java’s Fork/Join vs ExecutorService – when to use which?
  14. What is mutex and semaphore in Java ? What is the main difference?
  15. CountDownLatch vs. Semaphore
  16. Java threads and number of cores
  17. Parallel execution of directed acyclic graph of tasks
  18. Javafx: Difference between javafx.concurent and Platform.runLater?
  19. Simplest and understandable example of volatile keyword in Java
  20. Programmatic deadlock detection in java
  21. When should we use Java’s Thread over Executor?
  22. What is adaptive spinning w.r.t lock acquisition?
  23. Run Java Threads sequentially
  24. WAITING at sun.misc.Unsafe.park(Native Method)
  25. Java : Does wait() release lock from synchronized block
  26. How Threadpool re-use Threads and how it works
  27. What is the most frequent concurrency issue you’ve encountered in Java? [closed]
  28. LinkedBlockingQueue vs ConcurrentLinkedQueue
  29. Setting Ideal size of Thread Pool [duplicate]
  30. Does a breakpoint halt all threads?

Leave a Comment