Giriş
Açıklaması şöyle. Kilidi @RedisLockable ile otomatik bırakmak yerine kodla bırakmak için kullanılabilir
To release the lock early, you can use the LockRegistry interface provided by Spring Integration. You can inject the LockRegistry bean and obtain a lock on the same key used by the @RedisLockable annotation.
constructor - RedisConnectionFactory + registryKey
Örnek
Şöyle yaparız
private static final String LOCK_NAME = "lock";
@Bean(destroyMethod = "destroy")
public RedisLockRegistry redisLockRegistry(
RedisConnectionFactory redisConnectionFactory) {
return new RedisLockRegistry(redisConnectionFactory, LOCK_NAME);
}constructor - RedisConnectionFactory + registryKey + expireAfter
Açıklaması şöyle
When creating a RedisLockRegistry instance, you need to provide three parameters: `connectionFactory`, `registryKey`, and `expireAfter`.The `connectionFactory` parameter is used to generate the redisTemplate instance field within the RedisLockRegistry. This redisTemplate facilitates interaction with Redis using string values.The `registryKey` parameter serves as a prefix for key names. These key names are formed by combining the `registryKey` and the key’s specific value, separated by a colon. For example, if `registryKey` is set to “Spring” and you intend to lock a key with the value “Integration”, the actual key used to communicate with Redis would be “Spring:Integration”.The `expireAfter` parameter, of type long, determines the Time To Live (TTL) for the lock status data inserted into Redis by RedisLock instances.
Örnek
Şöyle yaparız
import org.springframework.data.redis.connection.RedisConnectionFactory;import org.springframework.integration.redis.util.RedisLockRegistry;import org.springframework.integration.support.locks.ExpirableLockRegistry;@Configurationpublic class RedisDistributedLockConfiguration {private static final String LOCK_REGISTRY_REDIS_KEY = "MY_REDIS_KEY";private static final Duration RELEASE_TIME_DURATION = Duration.ofSeconds(30);@Bean(LOCK_REGISTRY_BEAN)public ExpirableLockRegistry lockRegistry(RedisConnectionFactory redisConnectionFactory){RedisLockRegistry redisLockRegistry =new RedisLockRegistry(redisConnectionFactory, LOCK_REGISTRY_REDIS_KEY,RELEASE_TIME_DURATION.toMillis());return redisLockRegistry;}}
expireUnusedOlderThan metodu
Açıklaması şöyle
In some situations, you might need to acquire a lock but not release it. For example, you have a @Scheduled task that runs each 15 seconds on each instance and you don’t want it to be run more often than once per 15 seconds.
To do it you can get a lock and exit from a method without releasing. In such cases, I suggest calling lockRegistry.expireUnusedOlderThan(TTL) each time before obtaining a lock (actually it is better to call it for all cases). This method removes old not released locks from the map locks and prevents the situation when one instance has a map with old locks and all threads of this instance (except the one which acquired this lock) cannot acquire it.
obtain metodu
Açıklaması şöyle
Each object LockRegistry has a random id of type UUID and contains a map of locks (lock name / lock object) that are called locks and that are held by the current instance. When we do lockRegistry.obtain(lockKey), lockRegistry first checks if the map contains this lock (in other words, if the current instance has the lock with the same name acquired at this moment), if so then this lock is returned. Otherwise, lockRegistry checks if Redis contains the key with the name “registry key:lock name” and if the value equals the id of the lockRegistry object. If so, it returns this lock, else it tries to create the key “registry key:lock name” in Redis. When you got a lock and call lock.tryLock() basically the similar steps are performed as in lockRegistry.obtain(lockKey), first the map locks with locks is checked, then Redis.
Şöyle yaparız
import org.springframework.integration.support.locks.ExpirableLockRegistry; @Slf4j @Component public class LockService implements ILockService { @Qualifier(LOCK_REGISTRY_BEAN) @Autowired private ExpirableLockRegistry lockRegistry; @Override public boolean update(UpdateRequest request) { Lock lock = lockRegistry.obtain(request.getId()); boolean success = lock.tryLock(); if (!success) { return false; } // ... // update a shared resource // ... lock.unlock(); return true; } }
Örnek
Şöyle yaparız
@Service public class MyService { @Autowired private RedisLockRegistry redisLockRegistry; @RedisLockable(key = "my-lock-key", leaseTime = 60_000, waitTime = 5_000) public void doSomethingWithLock() throws InterruptedException { Lock lock = redisLockRegistry.obtain("my-lock-key"); try { // Do something with the lock } finally { lock.unlock(); } } }
setRedisLockType metodu
Açıklaması şöyle
... there can be configured 2 types of locks (both Reentrant ones)
- RedisLockType.SPIN_LOCK - the lock is acquired by periodic loop (100ms) checking whether the lock can be acquired. Default.
- RedisLockType.PUB_SUB_LOCK - The lock is acquired by redis pub-sub subscription.
The pub-sub is preferred mode — less network chatter between client Redis server, and more performant — the lock is acquired immediately when subscription is notified about unlocking in the other process. However, the Redis does not support pub-sub in the Master/Replica connections (for example in AWS ElastiCache environment), therefore a busy-spin mode is chosen as a default to make the registry working in any environment.
