final fields and thread-safety

by

In order to use an effectively immutable object without final fields in a thread safe manner you need to use one of safe publication idioms when making the object available to other threads after initialization, otherwise these threads can see the object in partially initialized state (from Java Concurrency in Practice):

  • Initializing an object reference from a static initializer;
  • Storing a reference to it into a volatile field or AtomicReference;
  • Storing a reference to it into a final field of a properly constructed object; or
  • Storing a reference to it into a field that is properly guarded by a lock.

Declaring fields of your immutable object as final releases this restriction (i.e. it guarantees that if other threads see a reference to the object, they also see its final fields in fully initialized state). However, in general case it doesn’t guarantee that other threads can see a reference to the object as soon as it was published, so you may still need to use safe publication to ensure it.

Note that if your object implements an interface, you can use an approach used by Collections.unmodifiableList(), etc:

class ImmutableFooWrapper implements IFoo {
    private final IFoo delegate; // final provides safe publication automatically

    public ImmutableFooWrapper(IFoo delegate) {
        this.delegate = delegate;
    }
    ...
}

public IFoo immutableFoo(IFoo foo) {
    return new ImmutableFooWrapper(foo);
}

More Related Contents:

  1. String is immutable. What exactly is the meaning? [duplicate]
  2. What is meant by immutable?
  3. Why is Java’s SimpleDateFormat not thread-safe? [duplicate]
  4. Immutable array in Java
  5. Immutable class?
  6. Why would one declare an immutable class final in Java?
  7. Is a HashMap thread-safe for different keys?
  8. Why do we need immutable class?
  9. Is HttpSession thread safe, are set/get Attribute thread safe operations?
  10. Thread safe multitons in Java
  11. Java Immutable Collections
  12. Is a volatile int in Java thread-safe?
  13. Is Integer Immutable
  14. Must Spring component classes be thread-safe
  15. How to stop a thread created by implementing runnable interface?
  16. Are primitive datatypes thread-safe in Java
  17. Are non-synchronised static methods thread safe if they don’t modify static class variables?
  18. Is it OK to use Gson instance as a static field in a model bean (reuse)?
  19. How do I prove programmatically that StringBuilder is not threadsafe?
  20. Mutable objects and hashCode
  21. Will the jit optimize new objects
  22. Make immutable Java object
  23. How to implement thread-safe lazy initialization?
  24. Thread Confinement
  25. Java Synchronization [closed]
  26. How to get the Context from anywhere? [duplicate]
  27. Is LinkedList thread-safe when I’m accessing it with offer and poll exclusively?
  28. Pattern for lazy thread-safe singleton instantiation in java
  29. Not thread-safe Object publishing
  30. Regarding thread safety of servlet [duplicate]

Leave a Comment