How compareAndSet works internally in redis

user_3656904 0
Viewed 1327

spring-data-redis module contains RedisAtomicLong class.

In this class you can see 

public boolean compareAndSet(long expect, long update) {

    return generalOps.execute(new SessionCallback<Boolean>() {

        @Override
        @SuppressWarnings("unchecked")
        public Boolean execute(RedisOperations operations) {
            for (;;) {
                operations.watch(Collections.singleton(key));
                if (expect == get()) {
                    generalOps.multi();
                    set(update);
                    if (operations.exec() != null) {
                        return true;
                    }
                }
                {
                    return false;
                }
            }
        }
    });
}

My question is why it works?

generalOps.multi() starts transaction after get() is invoked. It means that there is possibility that two different thread (or even client) can change value and both of them will succeed.

Is operations.watch prevent it somehow? JavaDoc doesn't explain purpose of this method.

PS: Minor question: why for (;;)? There is always one iteration.

redis spring java
3 Answers

Q: Is operations.watch prevent it somehow?

YES.

Quoting from Redis documentation about transaction:

WATCH is used to provide a check-and-set (CAS) behavior to Redis transactions.

WATCHed keys are monitored in order to detect changes against them. If at least one watched key is modified before the EXEC command, the whole transaction aborts, and EXEC returns a Null reply to notify that the transaction failed.

You can learn more about Redis transaction from that documentation.

Q: why for (;;)? There is always one iteration.

It seems the code you've posted is very old. From Google's cache of this url, I saw the code you provided which is dated back to Oct 15th, 2012!

Latest codes look much different:

user_40218020

Is operations.watch prevent it somehow?

YES. After watching a key, if the key has been modified before transaction finishes, EXEC will fail. So if EXEC successes, the value is guaranteed to be unchanged by others.

why for (;;)? There is always one iteration.

In your case, it seems the infinite loop is redundant.

However, if you want to implement a check-and-set operation to modify the value with the old value, the infinite loop is necessary. Check this example from redis doc:

WATCH mykey
val = GET mykey
val = val + 1
MULTI
SET mykey $val
EXEC

Since EXEC might fail, you need to retry the whole process in a loop until it successes.

user_53843630

RedisAtomicLong.compareAndSet implementation is not optimal since it requires 5 requests to Redis

Redisson - Redis Java client provides more efficient implementation.

org.redisson.RedissonAtomicLong#compareAndSetAsync method implemented using atomic EVAL-script:

  "local currValue = redis.call('get', KEYS[1]); "
+ "if currValue == ARGV[1] "
       + "or (tonumber(ARGV[1]) == 0 and currValue == false) then "
      + "redis.call('set', KEYS[1], ARGV[2]); "
      + "return 1 "
+ "else "
      + "return 0 "
+ "end",

This script requires only single request to Redis.

Usage example:

RAtomicLong atomicLong = redisson.getAtomicLong("myAtomicLong");
atomicLong.compareAndSet(1L, 2L);
user_7642060
Related