redis thread:
a) ...
b) ...
c) ...
d) ...
e) notified
f) write (K,V), it contains the mutations from thread1 or thread2

Thread1:
a) try lock L
b) get L, cachePut(K, V)
c) release L
d) mutate V (live ref to value pending write in cache)
e) all done

Thread 2:
a) try lock L
b) can't get L, wait for owner of L to release ("cool, someone else put it in cache, I'll use that")
c) V = cacheGet(K) (live ref to V, same as on Thread1)
d) mutate V
e) all done

function foo() {
    var someKey ="someKey-devredis"
    var someObj = {value: 42}
    cachePut(
        someKey,
        someObj,
        createTimeSpan( 9, 9, 9, 9 ),
        createTimeSpan( 9, 9, 9, 9 ),
        "default"
    )

    // sleep(20); // a sleep here will force the redis thread to win (and the value-written-to-redis will be 42)

    // if the value hasn't been written to redis yet, this live ref will alter the value that is waiting to be written
    // if the value has been written to redis, it appears this is not a live ref to the original object
    cacheGet(someKey).value = 999;

    // 42 or 999, depending on who won the race
    //
    // often, it is enough to run this file a few times to skew it to most-always 999 (though the prefereable value is 42)
    // (probably this gets the JIT warmed up, and then the race is more easily won by "this thread" rather
    // than the redis driver thread waiting on tokenAddToNear.wait())
    writedump(cacheGet(someKey) === someObj); // here the objects may or may not be identical
    writedump(cacheGet(someKey).value)

    sleep(100)
    cacheGet(someKey).value = 1000;
    writedump(cacheGet(someKey).value) // race is almost certainly over after 100ms, this is always the value that won the race earlier
    writedump(cacheGet(someKey) === someObj); // here the objects are almost certainly not identical after a 100ms allowance for the redis thread to do its work
}