locking safe with scopes & structs?

Question

Is it safe to use named locks (e.g. name of the key) to synchronize read/write access to specific keys of scopes & structs? I've been doing it for a while and never ran into concurrency issues, but I'm writing a server-level cache and I want to make sure name-based locking is safe with the server scope. I'm afraid the underlying implementation may not be thread-safe and that concurrent access on different keys could cause issues.

Answer 1

Locks in ColdFusion via cflock are just semaphores. They control which threads can access the code at the same time (concurrently). These locks do not impact Java's intrinsic locks or synchronized methods/statements. So cflock doesn't provide thread-safety per se.

User Ageax showed that CF structs do not use ConcurrentHashMap (see comments), so you have to explicitly use them: createObject("java", "java.util.concurrent.ConcurrentHashMap").init()
Note that ConcurrentHashMap is type and case sensitive (while the regular struct is not).

The good news

Structs in ColdFusion are thread-safe by nature. Here is an example that compares the unsafe Java HashMap and the safe ColdFusion Struct:

First run with:
<cfset s = createObject("java", "java.util.HashMap").init()>

Second run with:
<cfset s = structNew()>

<cfset s.put("A", 1)>
<cfset s.put("B", 2)>

<cfthread name="interrupter">
    <cfset s.put("C", 3)>
</cfthread>

<cfoutput>
    <cfloop collection="#s#" item="key">
        #s[key]#,
        <cfset sleep(1000)>
    </cfloop>
    #structKeyList(s)#
</cfoutput>

The HashMap will throw ConcurrentModificationException, because the map was accessed by the main thread while being modified by the "interrupter" thread.

The Struct however, will not throw an exception. It will simply return 1,2,A,B,C, because the iterator blocks access, i.e. causes the write operation by the "interrupter" thread to be postponed. After the iterator is done (end of loop), it releases the lock and the struct will be modified. This is why structKeyList() will immediately return the freshly written key-value-pair "C": 3 as well.

You can read more about the implementation details of concurrent map access in the official Java docs for java.util.concurrent.ConcurrentHashMap. But keep in mind that ColdFusion probably uses a derived version of ConcurrentHashMap.