The IAtomicLong is very useful if you need to deal with a long, but in some cases you need to deal with a reference. That is why Hazelcast also supports the IAtomicReference which is the distributed version of the java.util.concurrent.atomic.AtomicReference
.
So lets see the IAtomicReference in action:
public class Member {
public static void main(String[] args) {
Config config = new Config();
HazelcastInstance hz = Hazelcast.newHazelcastInstance(config);
IAtomicReference<String> ref = hz.getAtomicReference("reference");
ref.set("foo");
System.out.println(ref.get());
System.exit(0);
}
}
When you execute the above sample, you will see the below output.
foo
Just like the IAtomicLong, the IAtomicReference has a bunch of methods that accept a 'function' as argument like alter
, alterAndGet
, getAndAlter
and apply
. There are two big advantages of using these methods:
Of course there are some issues you need to be aware of as described below.
compareAndSet
method, it is important not to change to original value because its serialized content will then be different.
Also important to know is that, if you rely on Java serialization, sometimes (especially with hashmaps) the same object can result in different binary content.binary
. So the receiving side does not need to have the class definition available, unless it needs to be deserialized on the other side (e.g. because a method like 'alter' is executed. This deserialization is done for every call that needs to have the object instead of the binary content, so be careful with expensive object graphs that need to be deserialized.apply
method for that. This way the whole object does not need to be sent over the line, only the information that is relevant.