What is adaptive spinning w.r.t lock acquisition?

by

What exactly is adaptive spinning?

To quote from this Java 6 performance page:

Adaptive spinning is an optimization technique where a two-phase spin-then-block strategy is used by threads attempting a contended synchronized enter operation. This technique enables threads to avoid undesirable effects that impact performance such as context switching and repopulation of Translation Lookaside Buffers (TLBs). It is “adaptive” because the duration of the spin is determined by policy decisions based on factors such as the rate of success and/or failure of recent spin attempts on the same monitor and the state of the current lock owner.

So threads initially attempt to spin a couple of times trying to acquire a lock before actually blocking. Then in the future it uses previous success/fail metrics to adaptively determine whether it should try spinning or blocking. Spinning wastes CPU time while blocking may cause a context switch and the thread may wait for a longer amount of time than necessary. The goal is trying to optimize both of these issues based on past behavior.

For more details, the performance doc references this presentation entitled Synchronization in Java SE 6 (HotSpot) by Dave Dice. The first slide is titled “Contended costs (scalability + latency)”:

  • Context switching is extremely expensive
  • Unbounded spinning is unacceptable
  • Address via adaptive spinning

Later in the presentation there is the slide entitled “Adaptive Spinning”:

  • Spin-then-block strategy
    • Try to avoid context switch by spinning on [multi-processor] systems
  • Spin duration
    • Maintained per-monitor
    • varies based on recent history of spin success/failure ratio
  • Adapts to system load, parallelism, application modality
  • [multi-processor]-polite spinning
  • Avoid spinning in futile conditions (owner is blocked)

Interesting stuff.

More Related Contents:

  1. Synchronization vs Lock
  2. Run Java Threads sequentially
  3. WAITING at sun.misc.Unsafe.park(Native Method)
  4. ExecutorCompletionService? Why do need one if we have invokeAll?
  5. How to wait for all threads to finish, using ExecutorService?
  6. Is there an advantage to use a Synchronized Method instead of a Synchronized Block?
  7. Why is creating a Thread said to be expensive?
  8. When and how should I use a ThreadLocal variable?
  9. What is the difference between Thread.start() and Thread.run()?
  10. Java Wait and Notify: IllegalMonitorStateException
  11. How do synchronized static methods work in Java and can I use it for loading Hibernate entities?
  12. Is iterating ConcurrentHashMap values thread safe?
  13. Why use a ReentrantLock if one can use synchronized(this)?
  14. Is it safe to get values from a java.util.HashMap from multiple threads (no modification)?
  15. Is ConcurrentHashMap totally safe?
  16. How do I implement task prioritization using an ExecutorService in Java 5?
  17. Constructor synchronization in Java
  18. More efficient way for pausing loop wanted
  19. Instruction reordering & happens-before relationship [duplicate]
  20. When should we use Java’s Thread over Executor?
  21. ThreadPoolExecutor Block When its Queue Is Full?
  22. Java : Does wait() release lock from synchronized block
  23. How Threadpool re-use Threads and how it works
  24. Concurrent JUnit testing
  25. Whether to use invokeAll or submit – java Executor service
  26. Handling Exceptions for ThreadPoolExecutor
  27. Is having a single threadpool better design than multiple threadpools
  28. LinkedBlockingQueue vs ConcurrentLinkedQueue
  29. Does a breakpoint halt all threads?
  30. Are 64 bit assignments in Java atomic on a 32 bit machine?

Leave a Comment