AtomicInteger lazySet vs. set

by

Cited straight from “JDK-6275329: Add lazySet methods to atomic classes”:

As probably the last little JSR166 follow-up for Mustang,
we added a “lazySet” method to the Atomic classes
(AtomicInteger, AtomicReference, etc). This is a niche
method that is sometimes useful when fine-tuning code using
non-blocking data structures. The semantics are
that the write is guaranteed not to be re-ordered with any
previous write, but may be reordered with subsequent operations
(or equivalently, might not be visible to other threads) until
some other volatile write or synchronizing action occurs).

The main use case is for nulling out fields of nodes in
non-blocking data structures solely for the sake of avoiding
long-term garbage retention; it applies when it is harmless
if other threads see non-null values for a while, but you’d
like to ensure that structures are eventually GCable. In such
cases, you can get better performance by avoiding
the costs of the null volatile-write. There are a few
other use cases along these lines for non-reference-based
atomics as well, so the method is supported across all of the
AtomicX classes.

For people who like to think of these operations in terms of
machine-level barriers on common multiprocessors, lazySet
provides a preceeding store-store barrier (which is either
a no-op or very cheap on current platforms), but no
store-load barrier (which is usually the expensive part
of a volatile-write).

More Related Contents:

  1. Practical uses for AtomicInteger
  2. Java: is there no AtomicFloat or AtomicDouble?
  3. When is it preferable to use volatile boolean in Java rather than AtomicBoolean? [duplicate]
  4. Why must wait() always be in synchronized block
  5. How to share data with two(2) SwingWorker class in Java
  6. ConcurrentModificationException despite using synchronized
  7. Volatile vs Static in Java
  8. What operations in Java are considered atomic?
  9. How to make ThreadPoolExecutor’s submit() method block if it is saturated?
  10. When would you call java’s thread.run() instead of thread.start()?
  11. Convert from List to CompletableFuture
  12. Why there is no ConcurrentHashSet against ConcurrentHashMap
  13. How do I call some blocking method with a timeout in Java?
  14. Java Executors: how can I set task priority?
  15. What are the main uses of yield(), and how does it differ from join() and interrupt()?
  16. Volatile variable in Java
  17. What is the difference between synchronized on lockObject and using this as the lock?
  18. When should I use a CompletionService over an ExecutorService?
  19. Are non-synchronised static methods thread safe if they don’t modify static class variables?
  20. When do I need to use AtomicBoolean in Java?
  21. Java ExecutorService: awaitTermination of all recursively created tasks
  22. Writing long and double is not atomic in Java?
  23. Java concurrency: is final field (initialized in constructor) thread-safe?
  24. Jboss Java EE container and an ExecutorService
  25. Thread Confinement
  26. How to pause/resume all threads in an ExecutorService in Java?
  27. Multithreading Socket communication Client/Server
  28. How to atomically rename a file in Java, even if the dest file already exists?
  29. Controlling Task execution order with ExecutorService
  30. Are 64 bit assignments in Java atomic on a 32 bit machine?

Leave a Comment