Improper publication of Java Object Reference

by

You can imagine creation of an object has a number of non-atomic functions. First you want to initialize and publish Holder. But you also need to initialize all the private member fields and publish them.

Well, the JMM has no rules for the write and publication of the holder‘s member fields to happen before the write of the holder field as occurring in initialize(). What that means is that even though holder is not null, it is legal for the member fields to not yet be visible to other threads.

You may end up seeing something like

public class Holder {
    String someString = "foo";
    int someInt = 10;
}

holder may not be null but someString could be null and someInt could be 0.

Under an x86 architecture this is, from what I know, impossible to happen but may not be the case in others.

So next question may be “Why does volatile fix this?” The JMM says that all writes that happen prior to the volatile store are visible to all subsequent threads of the volatile field.

So if holder is volatile and you see holder is not null, based on volatile rules, all of the fields would be initialized.

To safely publish this object, do we have to make holder
initialization static and declare it as volatile

Yes, because as I mentioned if the holder variable is not null then all writes would be visible.

How can the AssertionError be thrown?

If a thread notices holder not to be null, and invokes AssertionError upon entering the method and reading n the first time may be 0 (the default value), the second read of n may now see the write from the first thread.

More Related Contents:

  1. Why must wait() always be in synchronized block
  2. How to share data with two(2) SwingWorker class in Java
  3. ConcurrentModificationException despite using synchronized
  4. Volatile vs Static in Java
  5. Swing – Update Label
  6. How to make ThreadPoolExecutor’s submit() method block if it is saturated?
  7. When would you call java’s thread.run() instead of thread.start()?
  8. Convert from List to CompletableFuture
  9. Why there is no ConcurrentHashSet against ConcurrentHashMap
  10. What are the main uses of yield(), and how does it differ from join() and interrupt()?
  11. What is the JVM thread scheduling algorithm?
  12. Why does Thread.isInterrupted () always return false?
  13. When should I use a CompletionService over an ExecutorService?
  14. Java memory model – can someone explain it?
  15. Are non-synchronised static methods thread safe if they don’t modify static class variables?
  16. When do I need to use AtomicBoolean in Java?
  17. Java ExecutorService: awaitTermination of all recursively created tasks
  18. Java concurrency: Countdown latch vs Cyclic barrier
  19. How to interrupt a BlockingQueue which is blocking on take()?
  20. Hashmap concurrency issue
  21. Which concurrent Queue implementation should I use in Java?
  22. Why should I use concurrent characteristic in parallel stream with collect?
  23. Java concurrency: is final field (initialized in constructor) thread-safe?
  24. Jboss Java EE container and an ExecutorService
  25. Why doesn’t volatile in java 5+ ensure visibility from another thread?
  26. Java: is there no AtomicFloat or AtomicDouble?
  27. How to pause/resume all threads in an ExecutorService in Java?
  28. Not thread-safe Object publishing
  29. notifyAll() throws IllegalMonitorStateException
  30. Will a chain of method calls (CompletableFuture API) execute asynchronously if the first method in a chain is asynchronous?

Leave a Comment