Synchronize access to mutable fields with Kotlin's map delegation

Question

Is this implementation safe to synchronize the access to the public fields/properties?

class Attributes(
    private val attrsMap: MutableMap<String, Any?> = Collections.synchronizedMap(HashMap())
) {

    var attr1: Long? by attrsMap
    var attr2: String? by attrsMap
    var attr3: Date? by attrsMap
    var attr4: Any? = null
    ...
}

Answer 1

Mostly.

Because the underlying map is is only accessible via the synchronised wrapper, you can't have any issues caused by individual calls, such as simultaneous gets and/or puts (which is the main cause of race conditions): only one thread can be making such a call, and the Java memory model ensures that the results are then visible to all threads.

You could have race conditions involving a sequence of calls, such as iterating through the map, or a check followed by a modify, if the map could be modified in between.  (That sort of problem can occur even on a single thread.)  But as long as the rest of your class avoided such sequences, and didn't leak a reference to the map, you'd be safe.

And because the types Long, String, and Date are immutable, you can't have any issues with their contents being modified.

That is a concern with the Any parameter, though.  If it stored e.g. a StringBuilder, one thread could be modifying its contents while another was accessing it, with hilarious consequences.  There's not much you can do about that in a wrapper class, though.

By the way, instead of using a synchronised wrapper, you could use a ConcurrentHashMap, which would avoid the synchronisation in most cases (at the cost of a bit more memory).  It also provides many methods which can replace call sequences, such as getOrPut(); it's a really powerful tool for writing high-performance multithreaded code.