Écrivez un code logique de survente simple et normal, plusieurs utilisateurs peuvent utiliser la même donnée à en même temps, explorez les problèmes qui se posent.
Stockez une information sur la quantité de produit dans Redis, demandez l'interface correspondante et obtenez des informations sur la quantité de produit
Si les informations sur la quantité de produit sont supérieures à 0, déduisez-en 1 et stockez-la à nouveau dans Redis ;
Exécutez le code pour tester le problème.
/**
* Redis数据库操作，超卖问题模拟
* @author
*
*/
@RestController
public class RedisController {
// 引入String类型redis操作模板
@Autowired
private StringRedisTemplate stringRedisTemplate;
// 测试数据设置接口
@RequestMapping("/setStock")
public String setStock() {
stringRedisTemplate.opsForValue().set("stock", "100");
return "ok";
}
// 模拟商品超卖代码
@RequestMapping("/deductStock")
public String deductStock() {
// 获取Redis数据库中的商品数量
Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
// 减库存
if(stock > 0) {
int realStock = stock -1;
stringRedisTemplate.opsForValue().set("stock", String.valueOf(realStock));
System.out.println("商品扣减成功，剩余商品："+realStock);
}else {
System.out.println("库存不足.....");
}
return "end";
}
}En mode application unique, utilisez jmeter pour appuyer sur Test. jmeter压测。
测试结果：
每个请求相当于一个线程，当几个线程同时拿到数据时，线程A拿到库存为84，这个时候线程B也进入程序，并且抢占了CPU，访问库存为84，最后两个线程都对库存减一，导致最后修改为83，实际上多卖出去了一件
既然线程和线程之间，数据处理不一致，能否使用synchronized加锁测试？
依旧还是先测试单服务器
// 模拟商品超卖代码,
// 设置synchronized同步锁
@RequestMapping("/deductStock1")
public String deductStock1() {
synchronized (this) {
// 获取Redis数据库中的商品数量
Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
// 减库存
if(stock > 0) {
int realStock = stock -1;
stringRedisTemplate.opsForValue().set("stock", String.valueOf(realStock));
System.out.println("商品扣减成功，剩余商品："+realStock);
}else {
System.out.println("库存不足.....");
}
}
return "end";
}数量100
重新压测，得到的日志信息如下所示：
在单机模式下，添加synchronized关键字，的确能够避免商品的超卖现象！
但是在分布式微服务中，针对该服务设置了集群，synchronized依旧还能保证数据的正确性吗？
假设多个请求，被注册中心负载均衡，每个微服务中的该处理接口，都添加有synchronized，
依然会出现类似的超卖问题：
synchronized只是针对单一服务器的JVM进行加锁，但是分布式是很多个不同的服务器，导致两个线程或多个在不同服务器上共同对商品数量信息做了操作！
在Redis中存在一条命令setnx (set if not exists)
setnx key value
如果不存在key，则可以设置成功；否则设置失败。
修改处理接口，增加key
// 模拟商品超卖代码
@RequestMapping("/deductStock2")
public String deductStock2() {
// 创建一个key，保存至redis
String key = "lock";
// setnx
// 由于redis是一个单线程，执行命令采取“队列”形式排队！
// 优先进入队列的命令先执行，由于是setnx，第一个执行后，其他操作执行失败。
boolean result = stringRedisTemplate.opsForValue().setIfAbsent(key, "this is lock");
// 当不存在key时，可以设置成功，回执true；如果存在key，则无法设置，返回false
if (!result) {
// 前端监测，redis中存在，则不能让这个抢购操作执行，予以提示！
return "err";
}
// 获取Redis数据库中的商品数量
Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
// 减库存
if(stock > 0) {
int realStock = stock -1;
stringRedisTemplate.opsForValue().set("stock", String.valueOf(realStock));
System.out.println("商品扣减成功，剩余商品："+realStock);
}else {
System.out.println("库存不足.....");
}
// 程序执行完成，则删除这个key
stringRedisTemplate.delete(key);
return "end";
}1、请求进入接口中，如果redis中不存在key，则会新建一个setnx；如果存在，则不会新建，同时返回错误编码，不会继续执行抢购逻辑。
2、当创建成功后，执行抢购逻辑。
3、抢购逻辑执行完成后，删除数据库中对应的setnx的key。让其他请求能够设置并操作。
这种逻辑来说比之前单一使用syn合理的多，但是如果执行抢购操作中出现了异常，导致这个key无法被删除。以至于其他处理请求，一直无法拿到key，程序逻辑死锁！
可以采取try … finally进行操作
/**
* 模拟商品超卖代码 设置
*
* @return
*/
@RequestMapping("/deductStock3")
public String deductStock3() {
// 创建一个key，保存至redis
String key = "lock";
// setnx
// 由于redis是一个单线程，执行命令采取队列形式排队！优先进入队列的命令先执行，由于是setnx，第一个执行后，其他操作执行失败
boolean result = stringRedisTemplate.opsForValue().setIfAbsent(key, "this is lock");
// 当不存在key时，可以设置成功，回执true；如果存在key，则无法设置，返回false
if (!result) {
// 前端监测，redis中存在，则不能让这个抢购操作执行，予以提示！
return "err";
}
try {
// 获取Redis数据库中的商品数量
Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
// 减库存
if (stock > 0) {
int realStock = stock - 1;
stringRedisTemplate.opsForValue().set("stock", String.valueOf(realStock));
System.out.println("商品扣减成功，剩余商品：" + realStock);
} else {
System.out.println("库存不足.....");
}
} finally {
// 程序执行完成，则删除这个key
// 放置于finally中，保证即使上述逻辑出问题，也能del掉
stringRedisTemplate.delete(key);
}
return "end";
}这个逻辑相比上面其他的逻辑来说，显得更加的严谨。
但是，如果一套服务器，因为断电、系统崩溃等原因出现宕机，导致本该执行finally中的语句未成功执行完成！！同样出现key一直存在，导致死锁！
在设置成功setnx后，以及抢购代码逻辑执行前，增加key的限时。
/**
* 模拟商品超卖代码 设置setnx保证分布式环境下，数据处理安全行问题；<br>
* 但如果某个代码段执行异常，导致key无法清理，出现死锁，添加try...finally;<br>
* 如果某个服务因某些问题导致释放key不能执行，导致死锁，此时解决思路为：增加key的有效时间;<br>
* 为了保证设置key的值和设置key的有效时间，两条命令构成同一条原子命令，将下列逻辑换成其他代码。
*
* @return
*/
@RequestMapping("/deductStock4")
public String deductStock4() {
// 创建一个key，保存至redis
String key = "lock";
// setnx
// 由于redis是一个单线程，执行命令采取队列形式排队！优先进入队列的命令先执行，由于是setnx，第一个执行后，其他操作执行失败
//boolean result = stringRedisTemplate.opsForValue().setIfAbsent(key, "this is lock");
//让设置key和设置key的有效时间都可以同时执行
boolean result = stringRedisTemplate.opsForValue().setIfAbsent(key, "this is lock", 10, TimeUnit.SECONDS);
// 当不存在key时，可以设置成功，回执true；如果存在key，则无法设置，返回false
if (!result) {
// 前端监测，redis中存在，则不能让这个抢购操作执行，予以提示！
return "err";
}
// 设置key有效时间
//stringRedisTemplate.expire(key, 10, TimeUnit.SECONDS);
try {
// 获取Redis数据库中的商品数量
Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
// 减库存
if (stock > 0) {
int realStock = stock - 1;
stringRedisTemplate.opsForValue().set("stock", String.valueOf(realStock));
System.out.println("商品扣减成功，剩余商品：" + realStock);
} else {
System.out.println("库存不足.....");
}
} finally {
// 程序执行完成，则删除这个key
// 放置于finally中，保证即使上述逻辑出问题，也能del掉
stringRedisTemplate.delete(key);
}
return "end";
}但是上述代码的逻辑中依旧会有问题：
如果处理逻辑中，出现
超时
Résultats des tests :
#🎜🎜# Testez toujours un seul serveur d'abord#🎜🎜#
Chaque requête équivaut à un thread Lorsque plusieurs threads obtiennent des données en même temps, le thread A amène l'inventaire à 84. À ce stade. Au moment où le thread B est également entré dans le programme et a préempté le processeur, l'inventaire accédé était de 84. Les deux derniers threads ont tous deux diminué l'inventaire de un, ce qui a entraîné la modification finale à 83. En fait, un article supplémentaire a été vendu
#. 🎜🎜#Depuis Le traitement des données est incohérent entre les threads. Puis-je utilisersynchronisépour verrouiller le test ?
Configurer la synchronisation#🎜🎜#Quantité/** * 模拟商品超卖代码 <br> * 解决`deductStock6`中，key形同虚设的问题。 * * @return */ @RequestMapping("/deductStock5") public String deductStock5() { // 创建一个key，保存至redis String key = "lock"; String lock_value = UUID.randomUUID().toString(); // setnx //让设置key和设置key的有效时间都可以同时执行 boolean result = stringRedisTemplate.opsForValue().setIfAbsent(key, lock_value, 10, TimeUnit.SECONDS); // 当不存在key时，可以设置成功，回执true；如果存在key，则无法设置，返回false if (!result) { // 前端监测，redis中存在，则不能让这个抢购操作执行，予以提示！ return "err"; } try { // 获取Redis数据库中的商品数量 Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock")); // 减库存 if (stock > 0) { int realStock = stock - 1; stringRedisTemplate.opsForValue().set("stock", String.valueOf(realStock)); System.out.println("商品扣减成功，剩余商品：" + realStock); } else { System.out.println("库存不足....."); } } finally { // 程序执行完成，则删除这个key // 放置于finally中，保证即使上述逻辑出问题，也能del掉 // 判断redis中该数据是否是这个接口处理时的设置的，如果是则删除 if(lock_value.equalsIgnoreCase(stringRedisTemplate.opsForValue().get(key))) { stringRedisTemplate.delete(key); } } return "end"; }Copier après la connexionCopier après la connexion100#🎜🎜##🎜🎜 ##🎜🎜##🎜🎜# En mode autonome, l'ajout du mot-clé synchronisé peut en effet éviter le phénomène de survente des produits ! #🎜🎜##🎜🎜#Mais dans un microservice distribué, si un cluster est mis en place pour le service, la synchronisation peut-elle encore garantir l'exactitude des données ? #🎜🎜##🎜🎜# En supposant que la charge de plusieurs requêtes est équilibrée par le centre d'enregistrement, l'interface de traitement dans chaque microservice est ajoutée avec une synchronisation, #🎜🎜##🎜🎜#
#🎜🎜##🎜🎜# Un
Survente</ code>Problème : #🎜🎜##🎜🎜##🎜🎜#<code>synchronisén'est effectué que sur laJVMd'unun seul serveurLock, mais la distribution s'effectue sur de nombreux serveurs différents, ce qui oblige deux ou plusieurs threads à exploiter conjointement les informations sur la quantité de produit sur différents serveurs ! #🎜🎜##🎜🎜#
#🎜🎜#Redis implémente le verrouillage distribué #🎜🎜##🎜🎜#Il y a une commande dans Redissetnx (défini s'il n'existe pas)# 🎜 🎜##🎜🎜##🎜🎜#setnx key value#🎜🎜#Si la clé n'existe pas, le réglage peut réussir sinon le réglage échoue. #🎜🎜##🎜🎜##🎜🎜#Modifier l'interface de traitement et ajouter une clé#🎜🎜##🎜🎜##🎜🎜#1 La requête entre dans l'interface Si la clé n'existe pas dans redis. un nouveau setnx sera créé. S'il existe, il ne sera pas créé, un code d'erreur sera renvoyé et la logique d'achat précipité ne continuera pas. #🎜🎜#2. Une fois la création réussie, exécutez la logique de snap-up. #🎜🎜#3. Une fois la logique d'achat précipitée exécutée, supprimez la@Component public class RedisLock { private final Logger log = LoggerFactory.getLogger(this.getClass()); private final long acquireTimeout = 10*1000; // 获取锁之前的超时时间(获取锁的等待重试时间) private final int timeOut = 20; // 获取锁之后的超时时间(防止死锁) @Autowired private StringRedisTemplate stringRedisTemplate; // 引入String类型redis操作模板 /** * 获取分布式锁 * @return 锁标识 */ public boolean getRedisLock(String lockName,String lockValue) { // 1.计算获取锁的时间 Long endTime = System.currentTimeMillis() + acquireTimeout; // 2.尝试获取锁 while (System.currentTimeMillis() < endTime) { //3. 获取锁成功就设置过期时间 让设置key和设置key的有效时间都可以同时执行 boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockName, lockValue, timeOut, TimeUnit.SECONDS); if (result) { return true; } } return false; } /** * 释放分布式锁 * @param lockName 锁名称 * @param lockValue 锁值 */ public void unRedisLock(String lockName,String lockValue) { if(lockValue.equalsIgnoreCase(stringRedisTemplate.opsForValue().get(lockName))) { stringRedisTemplate.delete(lockName); } } }Copier après la connexionCopier après la connexionkeydusetnxcorrespondant dans la base de données. Permet de configurer et de traiter d'autres demandes. #🎜🎜##🎜🎜##🎜🎜#Cette logique est bien plus raisonnable que d'utilisersynseul auparavant. Cependant, si une exception se produit lors de l'opération de snap-up, cettekey<. /code>ne peut pas être <code>supprimé. En conséquence, les autres requêtes de traitement n'ont pas pu obtenir lacléet la logique du programme est bloquée ! #🎜🎜##🎜🎜#Vous pouvez utiliser try...finally pour opérer #🎜🎜##🎜🎜#Cette logique est plus rigoureuse que l'autre logique ci-dessus. #🎜🎜##🎜🎜#Cependant, si un ensemble de serveurs@RestController public class RedisController { // 引入String类型redis操作模板 @Autowired private StringRedisTemplate stringRedisTemplate; @Autowired private RedisLock redisLock; @RequestMapping("/setStock") public String setStock() { stringRedisTemplate.opsForValue().set("stock", "100"); return "ok"; } @RequestMapping("/deductStock") public String deductStock() { // 创建一个key，保存至redis String key = "lock"; String lock_value = UUID.randomUUID().toString(); try { boolean redisLock = this.redisLock.getRedisLock(key, lock_value);//获取锁 if (redisLock) { // 获取Redis数据库中的商品数量 Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock")); // 减库存 if (stock > 0) { int realStock = stock - 1; stringRedisTemplate.opsForValue().set("stock", String.valueOf(realStock)); System.out.println("商品扣减成功，剩余商品：" + realStock); } else { System.out.println("库存不足....."); } } } finally { redisLock.unRedisLock(key,lock_value); //释放锁 } return "end"; } }Copier après la connexionCopier après la connexiontemps d'arrêtdû à une panne de courant, une panne du système, etc., les instructions dansfinalementqui doivent être exécutées seront ne sera pas exécuté. L'exécution s'est terminée avec succès ! ! Il semble également que laclé existe toujours, ce qui entraîne unimpasse! #🎜🎜##🎜🎜#Résolvez les problèmes ci-dessus via le délai d'attente #🎜🎜##🎜🎜#Après le réglage réussi desetnxet avant l'exécution de la logique du code d'achat précipité, augmentez la limite de temps de la clé . #🎜🎜#rrreee#🎜🎜#Mais il y aura toujours des problèmes dans la logique du code ci-dessus : #🎜🎜##🎜🎜##🎜🎜#S'il y a un problème detimeoutdans le logique de traitement. #🎜🎜#Lorsque la logique est exécutée et que le temps dépasse le temps de validité de la clé défini, quels problèmes se produiront à ce moment-là ? #🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜# Le problème est clairement visible sur l'image ci-dessus : #🎜🎜#Si le temps d'exécution d'une requête dépasse la durée de validité de la clé. #🎜🎜#Lorsqu'une nouvelle requête est exécutée, vous pourrez obtenir la clé et régler l'heure ; #🎜🎜#La clé enregistrée dans redis à ce moment n'est pas la clé de la requête 1, mais définie par d'autres requêtes. #🎜🎜#Une fois l'exécution de la requête 1 terminée, la clé est supprimée ici. Ce qui est supprimé, c'est la clé définie par les autres requêtes ! #🎜🎜#
依然出现了key形同虚设的问题！如果失效一直存在，超卖问题依旧不会解决。
既然出现key形同虚设的现象，是否可以增加条件，当finally中需要执行删除操作时，获取数据判断值是否是该请求中对应的，如果是则删除，不是则不管！
修改上述代码如下所示：
/**
* 模拟商品超卖代码 <br>
* 解决`deductStock6`中，key形同虚设的问题。
*
* @return
*/
@RequestMapping("/deductStock5")
public String deductStock5() {
// 创建一个key，保存至redis
String key = "lock";
String lock_value = UUID.randomUUID().toString();
// setnx
//让设置key和设置key的有效时间都可以同时执行
boolean result = stringRedisTemplate.opsForValue().setIfAbsent(key, lock_value, 10, TimeUnit.SECONDS);
// 当不存在key时，可以设置成功，回执true；如果存在key，则无法设置，返回false
if (!result) {
// 前端监测，redis中存在，则不能让这个抢购操作执行，予以提示！
return "err";
}
try {
// 获取Redis数据库中的商品数量
Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
// 减库存
if (stock > 0) {
int realStock = stock - 1;
stringRedisTemplate.opsForValue().set("stock", String.valueOf(realStock));
System.out.println("商品扣减成功，剩余商品：" + realStock);
} else {
System.out.println("库存不足.....");
}
} finally {
// 程序执行完成，则删除这个key
// 放置于finally中，保证即使上述逻辑出问题，也能del掉
// 判断redis中该数据是否是这个接口处理时的设置的，如果是则删除
if(lock_value.equalsIgnoreCase(stringRedisTemplate.opsForValue().get(key))) {
stringRedisTemplate.delete(key);
}
}
return "end";
}由于获得锁的线程必须执行完减库存逻辑才能释放锁，所以在此期间所有其他的线程都会由于没获得锁，而直接结束程序，导致有很多库存根本没有卖出去，所以这里应该可以优化，让没获得锁的线程等待，或者循环检查锁
我们将锁封装到一个实体类中，然后加入两个方法，加锁和解锁
@Component
public class RedisLock {
private final Logger log = LoggerFactory.getLogger(this.getClass());
private final long acquireTimeout = 10*1000; // 获取锁之前的超时时间(获取锁的等待重试时间)
private final int timeOut = 20; // 获取锁之后的超时时间(防止死锁)
@Autowired
private StringRedisTemplate stringRedisTemplate; // 引入String类型redis操作模板
/**
* 获取分布式锁
* @return 锁标识
*/
public boolean getRedisLock(String lockName,String lockValue) {
// 1.计算获取锁的时间
Long endTime = System.currentTimeMillis() + acquireTimeout;
// 2.尝试获取锁
while (System.currentTimeMillis() < endTime) {
//3. 获取锁成功就设置过期时间 让设置key和设置key的有效时间都可以同时执行
boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockName, lockValue, timeOut, TimeUnit.SECONDS);
if (result) {
return true;
}
}
return false;
}
/**
* 释放分布式锁
* @param lockName 锁名称
* @param lockValue 锁值
*/
public void unRedisLock(String lockName,String lockValue) {
if(lockValue.equalsIgnoreCase(stringRedisTemplate.opsForValue().get(lockName))) {
stringRedisTemplate.delete(lockName);
}
}
}@RestController
public class RedisController {
// 引入String类型redis操作模板
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private RedisLock redisLock;
@RequestMapping("/setStock")
public String setStock() {
stringRedisTemplate.opsForValue().set("stock", "100");
return "ok";
}
@RequestMapping("/deductStock")
public String deductStock() {
// 创建一个key，保存至redis
String key = "lock";
String lock_value = UUID.randomUUID().toString();
try {
boolean redisLock = this.redisLock.getRedisLock(key, lock_value);//获取锁
if (redisLock)
{
// 获取Redis数据库中的商品数量
Integer stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
// 减库存
if (stock > 0) {
int realStock = stock - 1;
stringRedisTemplate.opsForValue().set("stock", String.valueOf(realStock));
System.out.println("商品扣减成功，剩余商品：" + realStock);
} else {
System.out.println("库存不足.....");
}
}
} finally {
redisLock.unRedisLock(key,lock_value); //释放锁
}
return "end";
}
}可以看到失败的线程不会直接结束，而是会尝试重试，一直到重试结束时间，才会结束
实际上这个最终版依然存在3个问题
1、在finally流程中，由于是先判断在处理。如果判断条件结束后，获取到的结果为true。但是在执行del操作前，此时jvm在执行GC操作(为了保证GC操作获取GC roots根完全，会暂停java程序)，导致程序暂停。在GC操作完成并恢复后，执行del操作时，当前被加锁的key是否仍然存在？
2、问题如图所示
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!
Étapes de création du projet SpringBoot
Logiciel de base de données couramment utilisé
Que sont les bases de données en mémoire ?
Lequel a une vitesse de lecture plus rapide, mongodb ou redis ?
Comment utiliser Redis comme serveur de cache
Comment Redis résout la cohérence des données
Comment MySQL et Redis assurent-ils la cohérence des doubles écritures ?
Quelles données le cache Redis stocke-t-il généralement ?
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
