Java memory model – can someone explain it?

by

I’m not going to attempt to actually answer your questions here – instead I’ll redirect you to the book which I seeing recommended for advice on this topic: Java Concurrency in Practice.

One word of warning: if there are answers here, expect quite a few of them to be wrong. One of the reasons I’m not going to post details is because I’m pretty sure I’d get it wrong in at least some respects. I mean no disrespect whatsoever to the community when I say that the chances of everyone who thinks they can answer this question actually having enough rigour to get it right is practically zero. (Joe Duffy recently found a bit of the .NET memory model that was surprised by. If he can get it wrong, so can mortals like us.)

I will offer some insight on just one aspect, because it’s often misunderstood:

There’s a difference between volatility and atomicity. People often think that an atomic write is volatile (i.e. you don’t need to worry about the memory model if the write is atomic). That’s not true.

Volatility is about whether one thread performing a read (logically, in the source code) will “see” changes made by another thread.

Atomicity is about whether there is any chance that if a change is seen, only part of the change will be seen.

For instance, take writing to an integer field. That is guaranteed to be atomic, but not volatile. That means that if we have (starting at foo.x = 0):

Thread 1: foo.x = 257;
Thread 2: int y = foo.x;

It’s possible for y to be 0 or 257. It won’t be any other value, (e.g. 256 or 1) due to the atomicity constraint. However, even if you know that in “wall time” the code in thread 2 executed after the code in thread 1, there could be odd caching, memory accesses “moving” etc. Making the variable x volatile will fix this.

I’ll leave the rest up to real honest-to-goodness experts.

More Related Contents:

  1. What’s the difference between Thread start() and Runnable run()
  2. ExecutorService that interrupts tasks after a timeout
  3. Volatile boolean vs AtomicBoolean
  4. What are the advantages of using an ExecutorService?
  5. What’s a monitor in Java?
  6. How to use ConcurrentLinkedQueue?
  7. Write a program that will surely go into deadlock [closed]
  8. Java threads and number of cores
  9. Impossible to make a cached thread pool with a size limit?
  10. Java volatile reference vs. AtomicReference
  11. Memory effects of synchronization in Java
  12. Forcing multiple threads to use multiple CPUs when they are available
  13. ThreadPoolExecutor Block When Queue Is Full?
  14. Java ExecutorService: awaitTermination of all recursively created tasks
  15. Initializing two threads with the same instance of a runnable
  16. Why does Java not see the updated value from another thread?
  17. Writing long and double is not atomic in Java?
  18. What is adaptive spinning w.r.t lock acquisition?
  19. Java concurrency: is final field (initialized in constructor) thread-safe?
  20. Thread Confinement
  21. How can I wrap a method so that I can kill its execution if it exceeds a specified timeout?
  22. Why are two AtomicIntegers never equal?
  23. How to demonstrate race conditions around values that aren’t published properly?
  24. Java, divide incoming work uniformly via hashing in multithreaded evnironments
  25. How does ConcurrentHashMap work internally?
  26. Explain the timing causing HashMap.put() to execute an infinite loop
  27. Nested Java 8 parallel forEach loop perform poor. Is this behavior expected?
  28. Not thread-safe Object publishing
  29. ExecutorCompletionService? Why do need one if we have invokeAll?
  30. How to interrupt underlying execution of CompletableFuture

Leave a Comment