Qu'est-ce qu'un verrou réentrant ? Comment implémenter le verrouillage de réentrée ? L'article suivant vous donnera une discussion approfondie sur la façon dont Redis implémente les verrous de réentrée distribués. J'espère qu'il vous sera utile !
Qu'est-ce qu'un verrou non réentrant ?
C'est-à-dire que si le thread actuel exécute une méthode et a acquis le verrou, alors lorsqu'il tentera d'acquérir à nouveau le verrou dans la méthode, il ne pourra pas l'acquérir et sera bloqué.
Qu'est-ce qu'un verrou réentrant ?
Le verrouillage réentrant, également appelé verrouillage récursif, signifie que dans le même thread, une fois que la fonction externe a obtenu le verrou, la fonction récursive interne peut toujours obtenir le verrou.
Autrement dit, lorsque le même thread entre à nouveau le même code, il peut à nouveau obtenir le verrou.
La serrure peut-elle être rentrée ?
Empêchez les blocages d'acquérir le verrou plusieurs fois dans le même fil.
Remarque : Dans la programmation Java, synchronisé et ReentrantLock sont tous deux des verrous réentrants. 在java的编程中synchronized 和 ReentrantLock都是可重入锁。
基于synchronized的可重入锁
步骤1：双重加锁逻辑
public class SynchronizedDemo {
//模拟库存100
int count=100;
public synchronized void operation(){
log.info("第一层锁:减库存");
//模拟减库存
count--;
add();
log.info("下订单结束库存剩余:{}",count);
}
private synchronized void add(){
log.info("第二层锁：插入订单");
try {
Thread.sleep(1000*10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}Copier après la connexion
步骤2：加个测试类
public static void main(String[] args) {
SynchronizedDemo synchronizedDemo=new SynchronizedDemo();
for (int i = 0; i < 3; i++) {
int finalI = i;
new Thread(()->{
log.info("-------用户{}开始下单--------", finalI);
synchronizedDemo.operation();
}).start();
}
}Copier après la connexion
步骤3：测试
20:44:04.013 [Thread-2] INFO com.agan.redis.controller.SynchronizedController - -------用户2开始下单--------
20:44:04.013 [Thread-1] INFO com.agan.redis.controller.SynchronizedController - -------用户1开始下单--------
20:44:04.013 [Thread-0] INFO com.agan.redis.controller.SynchronizedController - -------用户0开始下单--------
20:44:04.016 [Thread-2] INFO com.agan.redis.Reentrant.SynchronizedDemo - 第一层锁:减库存
20:44:04.016 [Thread-2] INFO com.agan.redis.Reentrant.SynchronizedDemo - 第二层锁：插入订单
20:44:14.017 [Thread-2] INFO com.agan.redis.Reentrant.SynchronizedDemo - 下订单结束库存剩余:99
20:44:14.017 [Thread-0] INFO com.agan.redis.Reentrant.SynchronizedDemo - 第一层锁:减库存
20:44:14.017 [Thread-0] INFO com.agan.redis.Reentrant.SynchronizedDemo - 第二层锁：插入订单
20:44:24.017 [Thread-0] INFO com.agan.redis.Reentrant.SynchronizedDemo - 下订单结束库存剩余:98
20:44:24.017 [Thread-1] INFO com.agan.redis.Reentrant.SynchronizedDemo - 第一层锁:减库存
20:44:24.017 [Thread-1] INFO com.agan.redis.Reentrant.SynchronizedDemo - 第二层锁：插入订单
20:44:34.017 [Thread-1] INFO com.agan.redis.Reentrant.SynchronizedDemo - 下订单结束库存剩余:97
Copier après la connexion
- 由于synchronized关键字修饰的是方法，所有加锁为实例对象：synchronizedDemo
- 运行结果可以看出减库存和插入订单都是每个线程都完整运行两个方法完毕，才能释放锁，其他线程才能拿锁，即是一个线程多次可以拿到同一个锁，可重入。所以synchronized也是可重入锁。
基于ReentrantLock的可重入锁
ReentrantLock，是一个可重入且独占式的锁，是一种递归无阻塞的同步锁。和synchronized关键字相比，它更灵活、更强大，增加了轮询、超时、中断等高级功能。
步骤1：双重加锁逻辑
public class ReentrantLockDemo {
private Lock lock = new ReentrantLock();
public void doSomething(int n){
try{
//进入递归第一件事：加锁
lock.lock();
log.info("--------递归{}次--------",n);
if(n<=2){
try {
Thread.sleep(1000*2);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.doSomething(++n);
}else{
return;
}
}finally {
lock.unlock();
}
}
}Copier après la connexion
步骤2：加个测试类
public static void main(String[] args) {
ReentrantLockDemo reentrantLockDemo=new ReentrantLockDemo();
for (int i = 0; i < 3; i++) {
int finalI = i;
new Thread(()->{
log.info("-------用户{}开始下单--------", finalI);
reentrantLockDemo.doSomething(1);
}).start();
}
}Copier après la connexion
步骤3：测试
20:55:23.533 [Thread-1] INFO com.agan.redis.controller.ReentrantController - -------用户1开始下单--------
20:55:23.533 [Thread-2] INFO com.agan.redis.controller.ReentrantController - -------用户2开始下单--------
20:55:23.533 [Thread-0] INFO com.agan.redis.controller.ReentrantController - -------用户0开始下单--------
20:55:23.536 [Thread-1] INFO com.agan.redis.Reentrant.ReentrantLockDemo - --------递归1次--------
20:55:25.537 [Thread-1] INFO com.agan.redis.Reentrant.ReentrantLockDemo - --------递归2次--------
20:55:27.538 [Thread-1] INFO com.agan.redis.Reentrant.ReentrantLockDemo - --------递归3次--------
20:55:27.538 [Thread-2] INFO com.agan.redis.Reentrant.ReentrantLockDemo - --------递归1次--------
20:55:29.538 [Thread-2] INFO com.agan.redis.Reentrant.ReentrantLockDemo - --------递归2次--------
20:55:31.539 [Thread-2] INFO com.agan.redis.Reentrant.ReentrantLockDemo - --------递归3次--------
20:55:31.539 [Thread-0] INFO com.agan.redis.Reentrant.ReentrantLockDemo - --------递归1次--------
20:55:33.539 [Thread-0] INFO com.agan.redis.Reentrant.ReentrantLockDemo - --------递归2次--------
20:55:35.540 [Thread-0] INFO com.agan.redis.Reentrant.ReentrantLockDemo - --------递归3次--------
Copier après la connexion
- 运行结果可以看出，每个线程都可以多次加锁解锁的，ReentrantLock是可重入的。
redis如何实现分布式重入锁？
setnx虽然可以实现分布式锁，但是不可重入，在一些复杂的业务场景，我们需要分布式重入锁时,
对于redis的重入锁业界还是有很多解决方案的，目前最流行的就是采用RedissonVerrouillage réentrant basé sur la synchronisation
Étape 1 : Logique de double verrouillage
public class RedisController {
@Autowired
RedissonClient redissonClient;
@GetMapping(value = "/lock")
public void get(String key) throws InterruptedException {
this.getLock(key, 1);
}
private void getLock(String key, int n) throws InterruptedException {
//模拟递归，3次递归后退出
if (n > 3) {
return;
}
//步骤1：获取一个分布式可重入锁RLock
//分布式可重入锁RLock :实现了java.util.concurrent.locks.Lock接口，同时还支持自动过期解锁。
RLock lock = redissonClient.getLock(key);
//步骤2：尝试拿锁
// 1. 默认的拿锁
//lock.tryLock();
// 2. 支持过期解锁功能,10秒钟以后过期自动解锁, 无需调用unlock方法手动解锁
//lock.tryLock(10, TimeUnit.SECONDS);
// 3. 尝试加锁，最多等待3秒，上锁以后10秒后过期自动解锁
// lock.tryLock(3, 10, TimeUnit.SECONDS);
boolean bs = lock.tryLock(3, 10, TimeUnit.SECONDS);
if (bs) {
try {
// 业务代码
log.info("线程{}业务逻辑处理: {},递归{}" ,Thread.currentThread().getName(), key,n);
//模拟处理业务
Thread.sleep(1000 * 5);
//模拟进入递归
this.getLock(key, ++n);
} catch (Exception e) {
log.error(e.getLocalizedMessage());
} finally {
//步骤3：解锁
lock.unlock();
log.info("线程{}解锁退出",Thread.currentThread().getName());
}
} else {
log.info("线程{}未取得锁",Thread.currentThread().getName());
}
}
}Copier après la connexion
Étape 1 : Logique de double verrouillage
rrreee
Étape 2 : Ajouter une classe de test
rrreee
Étape 3 : Test
rrreee
Les résultats en cours on peut voir que chaque Thread peut être verrouillé et déverrouillé plusieurs fois, et ReentrantLock est réentrant.
Comment Redis implémente-t-il les verrous de réentrée distribués ?
- Bien que setnx puisse implémenter des verrous distribués, il n'est pas réentrant. Dans certains scénarios commerciaux complexes, lorsque nous avons besoin de verrous réentrants distribués,
Il existe de nombreuses solutions au verrouillage de réentrée de Redis dans l'industrie, et la plus populaire actuellement consiste à utiliser
Redisson. [Recommandations associées : Tutoriel vidéo Redis- ]
Redisson est la version Java du client Redis officiellement recommandée par Redis. Basé sur les interfaces communes de la boîte à outils utilitaires Java, il fournit aux utilisateurs une série de classes d'outils couramment utilisées avec des caractéristiques distribuées.
En termes de communication réseau, il est basé sur le framework Netty de NIO pour garantir des performances élevées de communication réseau. En termes de fonction de verrous distribués, il fournit une série de verrous distribués tels que :
Fair Lock (Fair Lock) UnFair Lock (unFair Lock)
ReadWriteLock( ReadWriteLock)Interlock(MultiLock)
🎜🎜Case Combat : Découvrez le verrouillage de réentrée distribué Redis🎜🎜🎜🎜🎜Étape 1 : Configuration de Redisson🎜🎜 🎜🎜La configuration de Redisson peut être vérifié : cache distribué redis (34) - Intégration SpringBoot avec Redission - Nuggets (juejin.cn)🎜🎜https://juejin.cn/post/7057132897819426824🎜🎜🎜🎜Étape 2 : Classe de test de verrouillage de réentrée Redisson 🎜🎜rrreee🎜RLock a trois actions de verrouillage : 🎜🎜🎜🎜🎜verrouillage par défaut 🎜🎜🎜🎜lock.tryLock(); 🎜🎜🎜🎜🎜🎜 prend en charge la fonction de déverrouillage d'expiration, 10 secondes. Il se déverrouillera automatiquement lorsqu'il expirera dans le futur🎜🎜🎜🎜lock .tryLock(10, TimeUnit.SECONDS);🎜🎜🎜🎜🎜🎜Essayez de verrouiller, attendez jusqu'à 3 secondes, il se déverrouillera automatiquement après l'expiration 10 secondes après le verrouillage🎜🎜🎜🎜🎜lock tryLock(3, 10, TimeUnit. .SECONDS);🎜🎜🎜🎜🎜🎜Différence : 🎜
- lock.lock()：阻塞式等待。默认加的锁都是30s
- 锁的自动续期，如果业务超长，运行期间自动锁上新的30s。不用担心业务时间长而导致锁自动过期被删掉（默认续期）
- 加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认会在30s内自动过期，不会产生死锁问题
- lock()如果我们未指定锁的超时时间，就使用【看门狗默认时间】： lockWatchdogTimeout = 30 * 1000
- 原理：只要占锁成功，就会启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】,每隔10秒都会自动的再次续期，续成30秒
- lock.lock(10,TimeUnit.SECONDS) ：10秒钟自动解锁,自动解锁时间一定要大于业务执行时间
- 出现的问题：在锁时间到了以后，不会自动续期
- 原理：lock(10,TimeUnit.SECONDS)如果我们传递了锁的超时时间，就发送给redis执行脚本，进行占锁，默认超时就是我们制定的时间
最佳实战：
步骤3:测试
访问3次：http://127.0.0.1:9090/lock?key=ljw
线程http-nio-9090-exec-1业务逻辑处理: ljw,递归1
线程http-nio-9090-exec-2未取得锁
线程http-nio-9090-exec-1业务逻辑处理: ljw,递归2
线程http-nio-9090-exec-3未取得锁
线程http-nio-9090-exec-1业务逻辑处理: ljw,递归3
线程http-nio-9090-exec-1解锁退出
线程http-nio-9090-exec-1解锁退出
线程http-nio-9090-exec-1解锁退出
Copier après la connexion
Copier après la connexion
通过测试结果：
- nio-9090-exec-1线程，在getLock方法递归了3次,即证明了lock.tryLock是可重入锁
- 只有当nio-9090-exec-1线程执行完后，io-9090-exec-2 nio-9090-exec-3 未取得锁
因为lock.tryLock(3, 10, TimeUnit.SECONDS)，尝试加锁，最多等待3秒，上锁以后10秒后过期自动解锁
所以等了3秒都等不到，就放弃了
总结
上面介绍了分布式重入锁的相关知识，证明了Redisson工具能实现了可重入锁的功能。其实Redisson工具包中还包含了读写锁（ReadWriteLock）和 红锁（RedLock）等相关功能，我们下篇文章再详细研究。
更多编程相关知识，请访问：编程入门！！
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
