Question

how

lets say i have this class

@ImmutableWannabe
public class ConfigurationHolder {
  @ImmutableButHowToMakeSureNoTwoThreadsOverrideOneEachOtherWhenReplacingReference
  private Map<System, Configuration> mySysConfig  = ImmutableMap.builder<>getSomeConfigurations....build();
  ConfigurationHolder(copy constructor) {
     mySysConfig = ImmutableMap.builder().of(inputSysConfig);
  }
}

Now lets say one of the systems configuration has updated and i need to update this map of however I need to do it in a thread safe way. which means if two threads try to update the same configuration of same system data should be consistent and they should not override one each other.

How did immutability help me here? As far as i can see i still need to do locking if yes how to do it properly?

so my general question is: isn’t it the case that any immutableObject which can change over system time will cause us to need to lock the code that will need to change its ImmutableObjectHolder? I don’t get it…

can someone please give a proper example of an ImmutableMap + Holder for that Map + proper “client” code that knows to update this ImmutableMapHolder with updates to the internal Map?

thanks

Answer 1

Assuming your map is some instance variable, the simplest way it to make it volatile. Alternatively, make a getter and setter for it and make them synchronized. i.e., use standard techniques. And note that this won’t help if the client tries to be clever and cache the value in a local variable. (I’ve bitten myself with this bug a couple of times.)

I guess as an alternative you could setup some MyImmutableChanged event/listener.

And, you are correct, immutability doesn’t solve every threading problem.