Update reference to immutable object thread-safe

Question

Suppose that multiple threads use a same Configuration object, sometimes reading a truly immutable object from it. Additionally, the reference to the immutable object could get updated.

public class Configuration {
    private ImmutableObject immutableObject;
    private ReentrantReadWriteLock lock;

    private void update() {
        lock.writeLock().lock();
        immutableObject = getNewImmutableObject();
        lock.writeLock().unlock();
    }

    public ImmutableObject getImmutableObject() {
        ImmutableObject newRef;
        lock.readLock().lock();
        newRef = immutableObject;
        lock.readLock().unlock();
        return newRef;
    }
}

Is this a good way to make the access of immutableObject thread-safe? I think I don't even need the lock, because the update of the reference is atomic, but I'm not sure.

Solomon Slow · Accepted Answer · 2017-02-24 18:44:37Z

2

I think I don't even need the lock, because the update of the reference is atomic

"Atomic" means that no thread will ever see a value for immutableObject that was not stored by some other thread, but it does not say when.

Without the synchronization, there is no guarantee about when (if ever) thread B will see the new value after thread A calls update(). Seriously, the Java language specification does not require that the value stored by thread A ever become visible to thread B unless some chain of "happens before" has been established between the two threads.

Locking and unlocking a Lock object establishes that relationship: Anything that thread A stores into any shared variable before it unlocks a lock is guaranteed to be seen by thread B after thread B locks the same lock.

There are various other ways to achieve the same effect. You could use synchronized, or you could use some java.utils.concurrent object such as a queue or a semaphore that implicitly synchronizes something.

Or, you could declare immutableObject to be volatile. Anything that thread A stores into a volatile variable is guaranteed to be visible to thread B when thread B subsequently reads the same volatile variable.

answered Feb 24, 2017 at 18:44

Solomon Slow

27.6k5 gold badges39 silver badges61 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

bloodopal Over a year ago

Thank you! I wasn't sure about the visibility too, but I forgot to add that to my question.

Collectives™ on Stack Overflow

Update reference to immutable object thread-safe

1 Answer 1

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related