分布式锁全面总结

于 2024-01-14 20:29:34 发布
阅读量839 收藏 26
点赞数 21
分类专栏： 分布式/微服务 文章标签： 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lastingboy/article/details/135585115
版权

分布式锁

分布式锁是用来解决分布式并发问题的

一、分布式并发问题

订单——商品超卖问题

1.1 实现提交订单接口开发

  1. 创建SpringBoot应用，整合mybatis和redis
  2. 创建商品信息表
  3. 完成提交订单接口
    校验库存（✔）
    保存订单
    生成订单快照
    案例：提交
    修改库存（✔）
    删除购物车
-- ----------------------------
-- Table structure for tb_products
-- ----------------------------
CREATE TABLE `tb_products` (
`product_id` int( 0 ) NOT NULL AUTO_INCREMENT,
`product_name` varchar( 50 ) CHARACTER SET utf8 COLLATE utf8_general_ci NOT
NULL,
`product_desc` varchar( 200 ) CHARACTER SET utf8 COLLATE utf8_general_ci NOT
NULL,
`product_stock` int( 0 ) NULL DEFAULT NULL,
PRIMARY KEY (`product_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 11 CHARACTER SET = utf8 COLLATE =
utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of tb_products
-- ----------------------------
INSERT INTO `tb_products` VALUES ( 1 , '小米10', '小米 10 描述信息', 3 );
INSERT INTO `tb_products` VALUES ( 2 , '华为P50', '华为P50描述信息', 12 );
INSERT INTO `tb_products` VALUES ( 3 , '康佳电视', '康佳电视描述信息', 11 );
INSERT INTO `tb_products` VALUES ( 4 , '铁三角麦克风', '铁三角麦克风描述信息', 9 );
INSERT INTO `tb_products` VALUES ( 5 , '海尔冰箱', '海尔冰箱描述信息', 12 );
INSERT INTO `tb_products` VALUES ( 6 , '美的空调', '美的空调描述信息', 6 );
INSERT INTO `tb_products` VALUES ( 7 , '联想笔记本', '联想笔记本描述信息', 6 );
INSERT INTO `tb_products` VALUES ( 8 , '哇哈哈', '哇哈哈描述信息', 6 );
INSERT INTO `tb_products` VALUES ( 9 , 'test', 'testdesc', 6 );
INSERT INTO `tb_products` VALUES ( 10 , '康师傅', '康师傅方便面', 6 );
SET FOREIGN_KEY_CHECKS = 1 ;

1.2 高并发访问测试

100 个并发请求同时购买一个商品——商品超卖

1.3 使用JVM锁解决商品超卖问题

当后端项目单机部署时，使用JVM锁可以解决由于提交订单的并发请求导致的商品超卖问题

@RestController
@CrossOrigin
@RequestMapping("/product")
public class ProductController {
@Autowired
private ProductService productService;
@PostMapping("/addorder")
public ResultVO submitOrder(Integer productId, Integer num){
ResultVO resultVO = null;
synchronized (productService) {
//开启事务
//提交订单业务
resultVO = productService.saveOrder(productId, num);
//提交事务
}
return resultVO;
}
}

1.4 分布式场景的并发访问测试

  • 将项目进行集群部署
    在这里插入图片描述

  • 并发访问测试
    在这里插入图片描述

  • 出现了商品超卖：
    在这里插入图片描述

二、如何解决分布式并发问题呢 ？

2.1 基于redis实现分布式锁

在这里插入图片描述

2.2 代码实现

@Service
public class OrderServiceImpl implements OrderService {
@Autowired
private ProductDAO productDAO;
@Value("${server.port}")
private int port;
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public ResultVO saveOrder(int productId, int num) {
//【加锁】：以当前商品的ID为key，向redis执行 setnx 1 aaa
// 设置成功则表示加锁成功
// 设置失败则表示加锁失败
boolean b = stringRedisTemplate.boundValueOps("" +
productId).setIfAbsent("aaa");
if(b){
try {
//加锁成功
//1.根据id查询库存
Product product = productDAO.selectById(productId);
//2.判断库存 (✔)
if (product.getProductStock() >= num) {
//3.保存订单
System.out.println(port + ":------------save order!");
//4.保存商品快照
//System.out.println("------------save order item!");
//5.修改商品库存
int i =
productDAO.updateStockById(productId,
product.getProductStock() - num);
if (i > 0) {
return new ResultVO(200, "下单成功！-" + port, null);
} else {
return new ResultVO(502, "下单失败！-" + port, null);
}
} else {
return new ResultVO(501, "商品库存不足！-" + port, null);
}
}catch (Exception e){
e.printStackTrace();
} finally {
//【释放锁】：del 1
stringRedisTemplate.delete(""+productId);
}
}else{
return null;
}
}
}

三、阻塞锁与非阻塞锁

  • 阻塞锁：不断尝试获取锁，直到获取到锁为止
  • 非阻塞锁：如果获取不到锁就放弃，但可以支持在一定时间段内的重试
           ——在一段时间内如果没有获取到锁就放弃

自定义阻塞锁的实现

@Service
public class OrderServiceImpl implements OrderService {
@Autowired
private ProductDAO productDAO;
@Value("${server.port}")
private int port;
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public ResultVO saveOrder(int productId, int num) {
//【加锁】：以当前商品的ID为key，向redis执行 setnx 1 aaa
// 设置成功则表示加锁成功
// 设置失败则表示加锁失败
boolean b = stringRedisTemplate.boundValueOps("" +
productId).setIfAbsent("aaa");
//如果b为false（加锁失败），不断的进行尝试
while(!b){
b = stringRedisTemplate.boundValueOps("" +
productId).setIfAbsent("aaa");
}
try {
//加锁成功
//1.根据id查询库存
Product product = productDAO.selectById(productId);
//2.判断库存 (✔)
if (product.getProductStock() >= num) {
//3.保存订单
System.out.println(port + ":------------save order!");
//4.保存商品快照
//System.out.println("------------save order item!");
//5.修改商品库存
int i = productDAO.updateStockById(productId,
product.getProductStock() - num);
if (i > 0) {
return new ResultVO(200, "下单成功！-" + port, null);
} else {
return new ResultVO(502, "下单失败！-" + port, null);
}
} else {
return new ResultVO(501, "商品库存不足！-" + port, null);
}
}catch (Exception e){
e.printStackTrace();
} finally {
//【释放锁】：del 1
stringRedisTemplate.delete(""+productId);
}
return null;
}
}

自定义非阻塞锁的实现

@Service
public class OrderServiceImpl implements OrderService {
@Autowired
private ProductDAO productDAO;
@Value("${server.port}")
private int port;
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public ResultVO saveOrder(int productId, int num) {
//【加锁】：以当前商品的ID为key，向redis执行 setnx 1 aaa
// 设置成功则表示加锁成功
// 设置失败则表示加锁失败
boolean b = stringRedisTemplate.boundValueOps("" +
productId).setIfAbsent("aaa");
//自定义非阻塞锁: 如果加锁失败，则尝试加锁，超时时间为3秒
long beginTime = System.currentTimeMillis();
while(!b && System.currentTimeMillis()<beginTime+3000){
b = stringRedisTemplate.boundValueOps("" +
productId).setIfAbsent("aaa");
}
if(b) {
try {
//加锁成功
//1.根据id查询库存
Product product = productDAO.selectById(productId);
//2.判断库存 (✔)
if (product.getProductStock() >= num) {
//3.保存订单
System.out.println(port + ":------------save order!");
//4.保存商品快照
//System.out.println("------------save order item!");
//5.修改商品库存
int i =
productDAO.updateStockById(productId,
product.getProductStock() - num);
if (i > 0) {
return new ResultVO(200, "下单成功！-" + port, null);
} else {
return new ResultVO(502, "下单失败！-" + port, null);
}
} else {
return new ResultVO(501, "商品库存不足！-" + port, null);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//【释放锁】：del 1
stringRedisTemplate.delete("" + productId);
}
}
return new ResultVO(503,"网络超时，请重试",null);
}
}

四、公平锁和非公平锁

公平锁和非公平锁 100 个线程 线程 3 剩下的 99 个要等待，当线程 3 执行结束以后，这 99 个线 程到底谁获取执行权呢？

  • 公平锁：按照线程的先后顺序获取锁
  • 非公平锁：多个正在等待的线程随机获取锁

在这里插入图片描述

五、分布式升级

问题①：

  • 当一个订单中包含多个商品时，如果订单中部分商品加锁成功，但是某一个加锁失败，导致最终加锁状态失败
  • 方案：如果一个订单包含多个商品，则依次对每个商品加锁，如果遇到加锁失败的商品，则需要对已经锁定的部分商品释放锁

问题②：

  • 能够先查询库存，在加锁呢？
  • 不能，因为在查询库存到加锁的这个过程中，库存可能被其他线程修改。

问题③：

  • 当当前线程加锁成功之后，执行业务过程中，如果当前线程出现异常导致无法释放锁，其他等待的线程则不能继续加锁执行业务，这个问题又该如何解决呢？
    在这里插入图片描述

5.1 解决因线程异常导致无法释放锁的问题

解决方案：在对商品进行加锁时，设置过期时间，这样以来即使线程出现故障无法释放锁，在过期时间结束时也会自动“释放锁”

boolean b = stringRedisTemplate.boundValueOps(productId + "")
.setIfAbsent("value",3,TimeUnit.MINUTES);

新的问题 ：
在这里插入图片描述

当给锁设置了过期时间之后，如果当前线程t1因为特殊原因，在锁过期前没有完成业务执行，将会释放锁，同时其他线程（t2）就可以成功加锁了，当t2加锁成功之后，t1执行结束释放锁就会释放t2的锁,就会导致t2在无锁状态下执行业务。

  • t1的锁因超时而自动释放，导致t2可以成功加锁，t1和t2就可能会出现并发问题
  • t1的锁因超时而自动释放，t2就可以加锁成功，t1业务执行完成之后会释放t2的锁（✔）

5.2 解决因t1过期释放t2锁的问题

在加锁的时候，为每个商品设置唯一的value，当释放锁的时候，先查询redis中当前商品锁对应的值与加锁的时候设置的值是否一致，如果一致则释放锁

  • 在加锁的时候，为每个商品设置唯一的value
String value = UUID.randomUUID().toString();
boolean b = stringRedisTemplate.boundValueOps(productId + "")
.setIfAbsent(value,3,TimeUnit.MINUTES);
  • 在释放锁的时候，先获取当前商品在redis中对应的value，如果获取的值与当前value相同，则释放锁
//查询操作
String v = stringRedisTemplate.boundValueOps(productId + "").get();
if(value.equals(v)){
//删除操作
stringRedisTemplate.delete(productId+"");
}

新的问题 ：

当释放锁的时候，在查询并判断“这个锁是当前线程加的锁”成功之后，正要进行删除时锁过期了，并且被其他线程成功加锁，一样会导致当前线程删除其他线程的锁。
在这里插入图片描述

  • Redis的操作都是原子性的
  • 要解决如上问题，必须保证查询操作和删除操作的原子性——使用lua脚本

5.3 使用lua脚本解决查询和删除的原子性问题

  • 在resources目录下创建unlock.lua,编辑脚本：
if redis.call("get",KEYS[1]) == ARGV[1] then
return redis.call("del",KEYS[1])
else
return 0
end
  • 配置Bean加载lua脚本
@Bean
public DefaultRedisScript<List> defaultRedisScript(){
DefaultRedisScript<List> defaultRedisScript = new DefaultRedisScript<>
();
defaultRedisScript.setResultType(List.class);
defaultRedisScript.setScriptSource(new ResourceScriptSource(new
ClassPathResource("unlock.lua")));
return defaultRedisScript;
}
  • 通过执行lua脚本解锁
@AutoWired
private DefaultRedisScript defaultRedisScript;
//执行lua脚本
List<String> keys = new ArrayList<>();
keys.add(skuId);
List rs = stringRedisTemplate.execute(defaultRedisScript,keys ,
values.get(skuId));
System.out.println(rs.get(0));

6.4 看门狗机制

问题：t1的锁因超时而自动释放，导致t2可以成功加锁，t1和t2就可能会出现并发问题

看门狗线程工作原理：

  • 监听当前线程锁的过期时间，当锁即将过期时如果业务没有执行结束，则重置锁的过期时间，保证业务线程正常执行的过程中，锁不会过期。

在这里插入图片描述

六、分布式锁框架-Redisson

基于Redis+看门狗机制的分布式锁框架

6.1 Redisson介绍

Redisson在基于NIO的Netty框架上，充分的利用了Redis键值数据库提供的一系列优势，在Java实用工具包中常用接口的基础上，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间的协作

6.2 在SpringBoot应用中使用Redisson

  • 添加依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.12.0</version>
</dependency>
  • 配置yml
redisson:
addr:
singleAddr:
host: redis://47.96.11.185:6380
password: 123456
database: 0
  • 配置RedissonClient
@Configuration
public class RedissonConfig {
@Value("${redisson.addr.singleAddr.host}")
private String host;
@Value("${redisson.addr.singleAddr.password}")
private String password;
@Value("${redisson.addr.singleAddr.database}")
private int database;
@Bean
public RedissonClient redissonClient(){
Config config = new Config();
config
.useSingleServer()
.setAddress(host)
.setPassword(password)
.setDatabase(database);
return Redisson.create(config);
}
}
  • 在秒杀业务实现中注入RedissonClient对象
@Service
public class ProductServiceImpl implements ProductService {
@Autowired
private ProductDAO productDAO;
@Autowired
private RedissonClient redissonClient;
@Transactional
synchronized public ResultVO saveOrder(int productId, int num) {
ResultVO resultVO = new ResultVO(504,"系统繁忙，请重试",null);
//获取锁（公平锁和非公平锁）
//RLock lock = redissonClient.getFairLock(productId + "");//获取公平锁
RLock lock = redissonClient.getLock(productId + "");//获取非公平锁
//加锁:在加锁的时候，可以设置是阻塞锁还是非阻塞锁
//lock.lock(); //阻塞锁
try {
boolean b = lock.tryLock(3,TimeUnit.SECONDS);//非阻塞锁
if(b){
//业务
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
return resultVO;
}
}

6.3 Redisson工作原理

在这里插入图片描述

6.4 Redisson使用扩展

6.4.1 Redisson单机连接

  • application.yml
redisson:
addr:
singleAddr:
host: redis://47.96.11.185:6370
password: 12345678
database: 0
  • RedissonConfig
@Configuration
public class RedissonConfig {
@Value("${redisson.addr.singleAddr.host}")
private String host;
@Value("${redisson.addr.singleAddr.password}")
private String password;
@Value("${redisson.addr.singleAddr.database}")
private int database;
@Bean
public RedissonClient redissonClient(){
Config config = new Config();
config.useSingleServer()
.setAddress(host)
.setPassword(password)
.setDatabase(database);
return Redisson.create(config);
}
}

6.4.2 Redisson集群连接

  • application.yml
redisson:
addr:
cluster:
hosts: redis://47.96.11.185:6370,...,redis://47.96.11.185:6373
password: 12345678
  • RedissonConfig——RedissonClient对象
@Configuration
public class RedissonConfig {
@Value("${redisson.addr.cluster.hosts}")
private String hosts;
@Value("${redisson.addr.cluster.password}")
private String password;
/**
* 集群模式
* @return
*/
@Bean
public RedissonClient redissonClient(){
Config config = new Config();
config.useClusterServers().addNodeAddress(hosts.split("[,]"))
.setPassword(password)
.setScanInterval(2000)
.setMasterConnectionPoolSize(10000)
.setSlaveConnectionPoolSize(10000);
return Redisson.create(config);
}
}

6.4.3 Redisson主从连接

  • application.yml
redisson:
addr:
masterAndSlave:
masterhost: redis://47.96.11.185:6370
slavehosts: redis://47.96.11.185:6371,redis://47.96.11.185:6372
password: 12345678
database: 0
  • RedissonConfig — RedissonClient
@Configuration
public class RedissonConfig3 {
@Value("${redisson.addr.masterAndSlave.masterhost}")
private String masterhost;
@Value("${redisson.addr.masterAndSlave.slavehosts}")
private String slavehosts;
@Value("${redisson.addr.masterAndSlave.password}")
private String password;
@Value("${redisson.addr.masterAndSlave.database}")
private int database;
/**
* 主从模式
* @return
*/
@Bean
public RedissonClient redissonClient(){
Config config = new Config();
config.useMasterSlaveServers()
.setMasterAddress(masterhost)
.addSlaveAddress(slavehosts.split("[,]"))
.setPassword(password)
.setDatabase(database)
.setMasterConnectionPoolSize(10000)
.setSlaveConnectionPoolSize(10000);
return Redisson.create(config);
}

6.5 分布式锁总结

6.5.1 分布式锁特点

1 、互斥性
和我们本地锁一样互斥性是最基本，但是分布式锁需要保证在不同节点的不同线程的互斥。
2 、可重入性
同一个节点上的同一个线程如果获取了锁之后那么也可以再次获取这个锁。
3 、锁超时
和本地锁一样支持锁超时，加锁成功之后设置超时时间，以防止线程故障导致不释放锁，防止死锁。
4 、高效，高可用
加锁和解锁需要高效，同时也需要保证高可用防止分布式锁失效，可以增加降级。redission是基于redis的，redis的故障就会导致redission锁的故障，因此redission支持单节点redis、reids主从、reids集群
5 、支持阻塞和非阻塞
和 ReentrantLock 一样支持 lock 和 trylock 以及 tryLock(long timeOut)。

6.5.2 锁的分类

1 、乐观锁与悲观锁

  • 乐观锁
  • 悲观锁

2 、可重入锁和非可重入锁

  • 可重入锁：当在一个线程中第一次成功获取锁之后，在此线程中就可以再次获取
  • 非可重入锁

3 、公平锁和非公平锁

  • 公平锁：按照线程的先后顺序获取锁
  • 非公平锁：多个线程随机获取锁

4 、阻塞锁和非阻塞锁

  • 阻塞锁：不断尝试获取锁，直到获取到锁为止
  • 非阻塞锁：如果获取不到锁就放弃，但可以支持在一定时间段内的重试
           ——在一段时间内如果没有获取到锁就放弃

6.5.3 Redission的使用

1 、获取锁——公平锁和非公平锁

//获取公平锁
RLock lock = redissonClient.getFairLock(skuId);
//获取非公平锁
RLock lock = redissonClient.getLock(skuId);

2 、加锁——阻塞锁和非阻塞锁

//阻塞锁（如果加锁成功之后，超时时间为30s；加锁成功开启看门狗，剩5s延长过期时间）
lock.lock();
//阻塞锁（如果加锁成功之后，设置自定义20s的超时时间）
lock.lock(20,TimeUnit.SECONDS);
//非阻塞锁（设置等待时间为3s；如果加锁成功默认超时间为30s）
boolean b = lock.tryLock(3,TimeUnit.SECONDS);
//非阻塞锁（设置等待时间为3s；如果加锁成功设置自定义超时间为20s）
boolean b = lock.tryLock(3,20,TimeUnit.SECONDS);

3 、释放锁

lock.unlock();

4 、应用示例

@Service
public class OrderServiceImpl implements OrderService {
@Autowired
private ProductDAO productDAO;
@Value("${server.port}")
private int port;
@Autowired
private RedissonClient redissonClient;
@Override
public ResultVO saveOrder(int productId, int num) throws
InterruptedException {
//获取锁： getLock 获取非公平锁 getFairLock 获取公平锁
RLock lock = redissonClient.getFairLock("" + productId);
//lock : 阻塞锁
lock.lock();
//tryLock ： 非阻塞锁
//boolean b = lock.tryLock(3,TimeUnit.SECONDS);
//执行订单业务
try {
//加锁成功
//1.根据id查询库存
Product product = productDAO.selectById(productId);
//2.判断库存 (✔)
if (product.getProductStock() >= num) {
//3.保存订单
System.out.println(port + ":------------save order!");
//4.保存商品快照
//System.out.println("------------save order item!");
//5.修改商品库存
int i = productDAO.updateStockById(productId,
product.getProductStock() - num);
if (i > 0) {
return new ResultVO(200, "下单成功！-" + port, null);
} else {
return new ResultVO(502, "下单失败！-" + port, null);
}
} else {
return new ResultVO(501, "商品库存不足！-" + port, null);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//释放锁
lock.unlock();
}
return new ResultVO(503,"网络超时，请重试",null);
}
}
我是二次元穿越来的
关注
  • 21
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
分布式锁的实现
weixin_44585214的博客
04-14 549
一、背景 在分布式系统中，一个应用部署在多台机器中，在某些场景下，为了保证数据的一致性，要求在同一时刻，同一任务只在一个节点上运行，即保证某个行为在同一时刻只能被一个线程执行。 在单机单进程多线程环境下，通过锁很容易做到，比如 mutex、spinlock、信号量等。 在多机多进程环境下，就需要使用分布式锁来解决了。 分布式场景：我们的应用由多个节点构成，这些节点可能分布在不同的机器中，也有可能分布在不同的网络环境中，通常这些进程之间通过 socket 进行通信。 二、分布式锁 是什么类型的锁
分布式锁简单入门以及三种实现方式介绍
u010724811的博客
10-26 370
分布式锁应该具备哪些条件 在分析分布式锁的三种实现方式之前，先了解一下分布式锁应该具备哪些条件： 1、在分布式系统环境下，一个方法在同一时间只能被一个机器的一个线程执行；  2、高可用的获取锁与释放锁；  3、高性能的获取锁与释放锁；  4、具备可重入特性；  5、具备锁失效机制，防止死锁；  6、具备非阻塞锁特性，即没有获取到锁将直接返回获取锁失败。 三、分布式锁的三种实现方式 目前几乎很多...
分布式锁解决方案
weixin_42940079的博客
07-30 660
一：为什么需要分布式锁？ 在传统的单机应用中，我们可以使用jvm层面的api实现锁来保证互斥控制，但是在分布式系统中，这种jvm域的锁就无法来实现对共享资源的控制了，这就需要使用分布式锁来结局分布式事务的问题了。 二：分布式锁所需要拥有的优点： 1：能够高性能的释放和获得锁 2：不会发生死锁 3：需要实现可重入锁 4：具备锁失效机制，不会发生死锁 5：具备阻塞锁特性，没有获得将继续等待获取锁 6：具备费阻塞锁特性，没有获得锁将直接返回获取锁失败。 三：分布式锁能解决什么问题？ 1：分布式session一致性
分布式锁Redisson详解（重点）
Java后端技术栈
12-25 4253
一、为什么需要分布式锁？ 在单体web应用的时候，如果多个线程要访问共享资源的时候，我们通常线程间加锁的机制，在某一个时刻，只有一个线程可以对这个资源进行操作，其他线程需要等待锁的释放，Java中也有一些处理锁的机制，比如synchronized。 而到了分布式的环境中，当某个资源可以被多个系统访问使用到的时候，为了保证大家访问这个数据是一致性的，那么就要求再同一个时刻，只能被一个系统使用，这时候线程之间的锁机制就无法起到作用了，因为分布式环境中，系统是会部署到不同的机器上面的，那么就需要【
分布式锁1：5种方案解决商品超卖的方案的优缺点
健康平安的活着的专栏
10-02 904
在多线程高并发场景下，为了保证资源的线程安全问题，jdk为我们提供了synchronized关键字和ReentrantLock可重入锁，但是它们只能保证一个工程内的线程安全。在分布式集群、微服务、云原生横行的当下，jdk并没有给我们提供既有的解决方案。需要自己通过编写方案来解决，目前主流的实现有以下方式：基于mysql关系型实现基于redis非关系型数据实现基于zookeeper/etcd实现。
分布式锁及实现方式
王文萱的博客
07-03 654
分布式锁及实现方式
架构系列——分布式锁
前方一片光明
07-15 1622
系统一旦分布式了之后，通信、缓存、消息、事务、锁、配置、日志、监控、会话等等各种原来单块系统场景下很容易解决的问题，都会变得很复杂，需要引入大量外部的技术。
redisson实现分布式锁
12-16
总结来说，Redisson的分布式锁是一种强大且灵活的工具，适用于需要高并发控制的分布式环境。结合AOP注解的使用，我们可以轻松地在Java应用中实现对关键操作的同步，保证数据的一致性和完整性。在实践中，我们需要...
案例实战-SpringBoot整合Redisson实现RedLock分布式锁同步
06-26
接下来，我们引入Redisson，这是一个全面的Java客户端，提供了丰富的Redis功能，包括分布式锁、队列、信号量等。RedLock是Redisson中的一个特性，它由Redis社区提出，旨在提供一种更健壮的分布式锁实现，比单节点...
多线程入门，分布式锁，等相关资料
11-28
总结来说，本资源包提供的"多线程入门资料"涵盖了多线程的基本概念、实现方式、线程同步与通信、并发问题及其解决方案，以及分布式锁的原理与实现，是学习Java多线程和分布式系统的好助手。通过深入学习和实践，...
Java面试题包涵基础，微服务分布式，数据库，jvm，网络，设计模式，算法，分布式锁和分布式事物等等
06-07
Java作为一门广泛使用的编程语言，其面试题涵盖了多个领域，包括基础语法、微服务与分布式...这些文档资料，如《Java基础核心总结》、《Java面试知识点总结》等，都是准备面试的良好资源，可以帮助你全面复习和准备。
基于Spring AOP 的声明式和编程式分布式锁，支持RedisTemplate、Redisson、Zookeeper
最新发布
04-09
总结来说，基于Spring AOP的声明式和编程式分布式锁，结合RedisTemplate、Redisson或Zookeeper，可以有效地解决分布式环境中的并发控制问题。这样的设计不仅简单易用，还能根据实际性能和环境需求灵活选择和扩展锁的...
由浅入深详解四种分布式锁
qq_42700121的博客
04-19 1019
分布式锁是由于单机锁无法满足分布式系统锁，在分布式环境下，需要分布式锁来控制共享内容，保证线程的安全。分布式满足几个特性互斥性超时释放锁自动续期分布式锁实现方式Mysql使用排它锁，。实现比较简单，但是数据库无法支撑大量请求访问，性能较差。Zookeeper先创建一个持久类型的节点，当多个线程请求时，在持久类型节点创建顺序临时节点，先判断自己是否是最小节点，如果是持有锁，执行后续逻辑，如果不是就找到上一个顺序节点，并添加watch监听事件。线程处理结束后。
分布式锁原理及实现
热门推荐
7me
08-26 1万+
目录前言概念什么是锁？什么是分布式？分布式与单机场景什么是分布式锁？场景为什么要使用分布式锁分布式锁应该具备的条件基于数据库的实现方式基于数据库表唯一约束基于表字段版本号做分布式锁基于数据库排他锁做分布式锁基于redis的实现方式基于ZooKeeper的实现方式总结 前言 分布式锁，是控制分布式系统之间同步访问共享资源的一种方式 在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要互斥来防止彼此干扰来保证一致性，在这种情况下
分布式锁
m0_63300795的博客
12-23 717
格式：setnx key value将key的值设置为value，当且仅当key不存在；若给定的key不存在，则setnx不做任何动作。setnx是（如果不存在，则set）的简写。setnx "zking" "xiaoliu" 第一次设置有效setnx "zking" "xiaoliu666" 第二次设置无效第一次使用setnx设置zking直接成功，第二次使用setnx设置zking则失败，也意味着加锁失败。redis级分布式锁之setnx使用。
使用分布式锁 解决订单超卖场景（二）
CSNZのBlog
10-15 722
巧用 Redis=>set 命令 解决订单超卖场景Redis具有极高的性能，且其命令对分布式锁支持友好，借助SET命令即可实现加锁处理。
springboot整合redisson实现分布式锁，实现商品下单库存扣减功能
Xmi2599的博客
05-24 3014
对于库存更新这样的场景，我们需要考虑对同一条记录进行更新并记录所可能出现的问题，比如读未提交造成的记录错乱。，也就是说，锁的过期时间到了，但是业务没处理完，那么redisson会自动给redis中的目标key延长超时时间，这在Redisson中称之为 Watch Dog 看门狗机制。如果不使用专业的分布式定时工具（如quartz），而是简单地依赖定时器来做定时任务，那么会有并发执行的情况，可能造成某些问题。锁资源被多个线程获取，成功则执行lua脚本，保存数据到redis数据库。（2）分布式锁工具类。
分布式锁的实现方式
谈谈1974
08-11 316
1. 产生原因 分布式应用通常需要考虑数据一致性问题 .分布式的CAP理论认为 “任何一个分布式系统都无法同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance），最多只能同时满足两项。”在大多数的场景中，牺牲强一致性来换取系统的高可用性是可以接受的，系统往往只需要保证“最终一致性”，只要这个最终时间是在用户可以接受的范围内...
ZooKeeper 28 道面试题及答案.docx
07-07
ZooKeeper 28 道面试题及答案.docx

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我是二次元穿越来的

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值