关于缓存分布式锁

最新推荐文章于 2024-06-11 21:53:04 发布
最新推荐文章于 2024-06-11 21:53:04 发布
阅读量512 收藏 3
点赞数 1
文章标签： 缓存 分布式 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45818966/article/details/126260321
版权

目录

缓存

1.缓存的使用

2.整合redis

给业务中加入缓存

缓存失效问题

1.缓存穿透

2.缓存雪崩

缓存数据一致性

先写缓存，再写数据库（差）

先写数据库，再写缓存（一般）

先删缓存，再写数据库（能接受）

先写数据库，再删缓存（比较优秀）

分布式锁

1.使用 Redis 作为分布式锁

2.Redisson 作为分布式锁

SpringCache

1.引入依赖

2.添加配置

3.常用注解

4.业务实现

缓存

1.缓存的使用

使用缓存的目的就是提升读写性能。而实际业务场景下，更多的是为了提升读性能，带来更好的性 能，带来更高的并发量。Redis 的读写性能比 Mysql 好的多，我们就可以把 Mysql 中的热点数据缓 存到 Redis 中，提升读取性能，同时也减轻了 Mysql 的读取压力。

具体流程：

data = cache.load(id);//从缓存加载数据
If(data == null){
data = db.load(id);//从数据库加载数据
cache.put(id,data);//保存到 cache 中
}
return data

2.整合redis

会产生堆外内存溢出异常：OutOfDirectMemoryError。

原因：

  1. SpringBoot 2.0 以后默认使用 lettuce 作为操作 redis 的客户端，它使用 netty 进行网络通信；
  2.  lettuce 的 bug 导致 netty 堆外内存溢出；
  3. netty 如果没有指定堆外内存，默认使用 -Xmx 参数指定的内存；
  4. 可以通过 -Dio.netty.maxDirectMemory 进行设置；

解决方案：

   升级 lettuce 客户端，或使用 jedis 客户端

1、引入 redis-starter
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2、配置 redis
spring:
redis:
host: 192.168.56.10
port: 6379
3、使用 RedisTemplate 操作 redis
@Autowired
StringRedisTemplate stringRedisTemplate;
@Test
public void testStringRedisTemplate(){
ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
ops.set("hello","world_"+ UUID.randomUUID().toString());
String hello = ops.get("hello");
System.out.println(hello);
}
4、切换使用 jedis
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<exclusions>
<exclusion>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>

给业务中加入缓存

这里使用依赖中自带的 StringRedisTemplate 来操作 Redis。这里存储的值为转化成 JSON 字符串的对象信息。

@Autowired
StringRedisTemplate redisTemplate;
@Override
public Map<String, List<Catalogs2Vo>> getCatalogJson() {
    // 1.从缓存中读取分类信息
    String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
    if (StringUtils.isEmpty(catalogJSON)) {
        // 2. 缓存中没有，查询数据库
        Map<String, List<Catalogs2Vo>> catalogJsonFromDB = getCatalogJsonFromDB();
        // 3. 查询到的数据存放到缓存中，将对象转成 JSON 存储
        redisTemplate.opsForValue().set("catalogJSON", JSON.toJSONString(catalogJsonFromDB));
        return catalogJsonFromDB;
    }
    return JSON.parseObject(catalogJSON, new TypeReference<Map<String, List<Catalogs2Vo>>>(){});
}

/**
 * 加缓存前,只读取数据库的操作
 *
 * @return
 */
public Map<String, List<Catalogs2Vo>> getCatalogJsonFromDB() {
    System.out.println("查询了数据库");

    // 性能优化：将数据库的多次查询变为一次
    List<CategoryEntity> selectList = this.baseMapper.selectList(null);

    //1、查出所有分类
    //1、1）查出所有一级分类
    List<CategoryEntity> level1Categories = getParentCid(selectList, 0L);

    //封装数据
    Map<String, List<Catalogs2Vo>> parentCid = level1Categories.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), v -> {
        //1、每一个的一级分类,查到这个一级分类的二级分类
        List<CategoryEntity> categoryEntities = getParentCid(selectList, v.getCatId());

        //2、封装上面的结果
        List<Catalogs2Vo> catalogs2Vos = null;
        if (categoryEntities != null) {
            catalogs2Vos = categoryEntities.stream().map(l2 -> {
                Catalogs2Vo catalogs2Vo = new Catalogs2Vo(v.getCatId().toString(), null, l2.getCatId().toString(), l2.getName().toString());

                //1、找当前二级分类的三级分类封装成vo
                List<CategoryEntity> level3Catelog = getParentCid(selectList, l2.getCatId());

                if (level3Catelog != null) {
                    List<Catalogs2Vo.Category3Vo> category3Vos = level3Catelog.stream().map(l3 -> {
                        //2、封装成指定格式
                        Catalogs2Vo.Category3Vo category3Vo = new Catalogs2Vo.Category3Vo(l2.getCatId().toString(), l3.getCatId().toString(), l3.getName());

                        return category3Vo;
                    }).collect(Collectors.toList());
                    catalogs2Vo.setCatalog3List(category3Vos);
                }

                return catalogs2Vo;
            }).collect(Collectors.toList());
        }

        return catalogs2Vos;
    }));

    return parentCid;
}

缓存失效问题

1.缓存穿透

缓存穿透是指 查询一个一定不存在的数据，由于缓存是不命中，将去查询数据库，但是数据库也无此记录，我们没有将这次查询的 null 写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。在流量大时，可能 DB 就挂掉了，要是有人利用不存在的 key 频繁攻击我们的应用，这就是漏洞。

解决方法：缓存空结果、并且设置短的过期时间。

2.缓存雪崩

缓存雪崩是指在我们设置缓存时采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到 DB，DB 瞬时压力过重雪崩。

解决方法：原有的失效时间基础上增加一个随机值，比如 1-5 分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。

3.缓存击穿

对于一些设置了过期时间的 key，如果这些 key 可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。这个时候，需要考虑一个问题：如果这个 key 在大量请求同时进来前正好失效，那么所有对这个 key 的数据查询都落到 db，我们称为缓存击穿。

解决方法：加锁。大量并发只让一个人去查，其他人等待，查到之后释放锁，其他人获取到锁，先查缓存，就会有数据，不用去查数据库。

缓存数据一致性

当数据库有数据更新时，在很长的一段时间内（决定于缓存的过期时间），用户请求从缓存中获取到的都可能是旧值，而非数据库的最新值。那么，该如何更新缓存呢？目前有以下四种解决方案：

先写缓存，再写数据库（差）

缺点：如果刚写完缓存，突然网络出现了异常，导致写数据库失败了。这样缓存中的数据就变成脏数据，这个问题非常严重，也是最差的一种解决方案。

先写数据库，再写缓存（一般）

缺点一：问题又来了，写数据库成功，但写缓存失败了，依然会造成缓存脏数据的问题。但写缓存失败比写数据库失败的概率要小很多了(因为数据库可能有加锁、外键约束、超时等机制限制)，所以此方案要比第一种方案好一点。

如果对接口性能要求不高，还可以把写数据库和写缓存放到一个事务中，写缓存失败就回滚数据库。

缺点二：高并发情况下：

  1. 请求a先过来，刚写完了数据库。但由于网络原因，卡顿了一下，还没来得及写缓存。
  2. 这时候请求b过来了，先写了数据库。
  3. 接下来，请求b顺利写了缓存。
  4. 此时，请求a卡顿结束，也写了缓存。

也就是说：在高并发场景中，如果多个线程同时执行先写数据库，再写缓存的操作，可能会出现数据库是新值，而缓存中是旧值，两边数据不一致的情况。

先删缓存，再写数据库（能接受）

缺点：

  1. 请求d先过来，把缓存删除了。但由于网络原因，卡顿了一下，还没来得及写数据库。
  2. 这时请求c过来了，先查缓存发现没数据，再查数据库，有数据，但是旧值。
  3. 请求c将数据库中的旧值，更新到缓存中。
  4. 此时，请求d卡顿结束，把新值写入数据库。

这种极端情况下依然会导致写入的缓存为旧值。

延迟双删

为了避免以上，写完数据库后，再删除一次。

该方案有个非常关键的地方是：第二次删除缓存，并非立马就删，而是要在一定的时间间隔之后。

sleep的时间要对业务读写缓存的时间做出评估，sleep时间大于读写缓存的时间即可。

那么，为什么一定要间隔一段时间之后，才能删除缓存呢？

请求d卡顿结束，把新值写入数据库后，请求c将数据库中的旧值，更新到缓存中。此时，如果请求d删除太快，在请求c将数据库中的旧值更新到缓存之前，就已经把缓存删除了，这次删除就没任何意义。必须要在请求c更新缓存之后，再删除缓存，才能把旧值及时删除了。

先写数据库，再删缓存（比较优秀）

缓存和数据库，无论先处理谁，只要后者有延迟/失败，都会导致不一致的情况，这也正是缓存不一致的根本原因所在。所有解决方案和讨论都是围绕这一点来进行的。

  1. 请求1先写数据库，由于网络原因卡顿了一下，没有来得及删除缓存。
  2. 请求2查询缓存，发现缓存中有数据，直接返回该数据。
  3. 请求1删除缓存

这种情况下，只会影响f或类似f的少数请求读了一次脏数据，看起来好多了。

但如果是读数据请求先过来呢？

  1. 请求2查询缓存，发现缓存中有数据，直接返回该数据。
  2. 请求1先写数据库。
  3. 请求1删除缓存。

总结：

  1. 想要提高应用的性能，可以引入「缓存」来解决
  2. 引入缓存后，需要考虑缓存和数据库一致性问题，可选的方案有：「更新数据库 + 更新缓存」、「更新数据库 + 删除缓存」
  3. 更新数据库 + 更新缓存方案，在「并发」场景下无法保证缓存和数据一致性，解决方案是加「分布锁」，但这种方案存在「缓存资源浪费」和「机器性能浪费」的情况
  4. 采用「先删除缓存，再更新数据库」方案，在「并发」场景下依旧有不一致问题，解决方案是「延迟双删」，但这个延迟时间很难评估
  5. 采用「先更新数据库，再删除缓存」方案，为了保证两步都成功执行，需配合「消息队列」或「订阅变更日志」的方案来做，本质是通过「重试」的方式保证数据最终一致
  6. 采用「先更新数据库，再删除缓存」方案，「读写分离 + 主从库延迟」也会导致缓存和数据库不一致，缓解此问题的方案是「延迟双删」，凭借经验发送「延迟消息」到队列中，延迟删除缓存，同时也要控制主从库延迟，尽可能降低不一致发生的概率

具体参考：http://kaito-kidd.com/2021/09/08/how-to-keep-cache-and-consistency-of-db/

分布式锁

本地锁只能锁住当前服务的进程，每一个单独的服务都会有一个进程读取数据库，不能达到只读取依次数据库的效果，所以需要分布式锁。

1.使用 Redis 作为分布式锁

redis 中有一个 SETNX 命令，该命令会向 redis 中保存一条数据，如果不存在则保存成功，存在则返回失败。

我们约定保存成功即为加锁成功，之后加锁成功的线程才能执行真正的业务操作。

/**
* 从数据库查询并封装数据::分布式锁
*
* @return
*/
public Map<String, List<Catalogs2Vo>> getCatalogJsonFromDbWithRedisLock() {

    //1、占分布式锁。去redis占坑 设置过期时间必须和加锁是同步的，保证原子性（避免死锁）
    String uuid = UUID.randomUUID().toString();
    Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 300, TimeUnit.SECONDS);
    if (lock) {
        System.out.println("获取分布式锁成功...");
        Map<String, List<Catalogs2Vo>> dataFromDb = null;
        try {
            //加锁成功...执行业务
            dataFromDb = getCatalogJsonFromDB();
        } finally {
            // lua 脚本解锁
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            // 删除锁
            redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Collections.singletonList("lock"), uuid);
        }
        //先去redis查询下保证当前的锁是自己的
        //获取值对比，对比成功删除=原子性 lua脚本解锁
        // String lockValue = stringRedisTemplate.opsForValue().get("lock");
        // if (uuid.equals(lockValue)) {
        //     //删除我自己的锁
        //     stringRedisTemplate.delete("lock");
        // }
        return dataFromDb;
    } else {
        System.out.println("获取分布式锁失败...等待重试...");
        //加锁失败...重试机制
        //休眠一百毫秒
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return getCatalogJsonFromDbWithRedisLock();     //自旋的方式
    }
}

2.Redisson 作为分布式锁

1.引入依赖

 <dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson</artifactId>
   <version>3.11.1</version>
</dependency>

2.配置redisson

@Configuration
public class MyRedissonConfig {

    /**
     * 所有丢redis的使用都是通过RedissonClient对象
     * @return
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() {
        // 1、创建配置
        Config config = new Config();
        // Redis url should start with redis:// or rediss://
        //使用单节点方式
        config.useSingleServer().setAddress("redis://192.168.56.10:6379");

        RedissonClient redissonClient = Redisson.create(config);
        // 2、根据 Config 创建出 RedissonClient 实例
        return redissonClient;
    }

3.使用

// 1. 获取一把锁
Rlock lock = redisson.getLock("my-lock");

// 2. 加锁, 阻塞式等待
lock.lock();
try {
	System.out.println("加锁成功，执行业务...");
} catch (Exception e) {
} finally {
	// 3. 解锁 假设解锁代码没有运行，Redisson 会出现死锁吗？（不会）
    lock.unlock();
}
  • 锁的自动续期，如果业务时间很长，运行期间自动给锁续期 30 s，不用担心业务时间过长，锁自动过期被删掉；
  • 加锁的业务只要运行完成，就不会给当前锁续期，即使不手动续期，默认也会在 30 s 后解锁；

修改上述代码为

    /**
     * 缓存里的数据如何和数据库的数据保持一致？？
     * 缓存数据一致性
     * 1)、双写模式
     * 2)、失效模式
     *
     * @return
     */
    public Map<String, List<Catalogs2Vo>> getCatalogJsonFromDbWithRedissonLock() {

        //1、占分布式锁。去redis占坑
        //（锁的粒度，越细越快:具体缓存的是某个数据，11号商品） product-11-lock
        //RLock catalogJsonLock = redissonClient.getLock("catalogJson-lock");
        //创建读锁
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("catalogJson-lock");

        RLock rLock = readWriteLock.readLock();

        Map<String, List<Catalogs2Vo>> dataFromDb = null;
        try {
            rLock.lock();
            //加锁成功...执行业务
            dataFromDb = getCatalogJsonFromDB();
        } finally {
            rLock.unlock();
        }
        return dataFromDb;
    }

SpringCache

1.引入依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

2.添加配置

spring.cache.type=redis

#spring.cache.cache-names=

#毫秒为单位
spring.cache.redis.time-to-live=3600000
#spring.cache.redis.key-prefix=CACHE_
spring.cache.redis.use-key-prefix=true
#是否缓存空值 防止缓存穿透
spring.cache.redis.cache-null-values=false
@EnableConfigurationProperties(CacheProperties.class)
@Configuration
@EnableCaching
public class MyCacheConfig {


    /**
     * 配置文件中的东西没用上（ttl）；应该将配置文件中的所有配置都生效
     * <p>
     * 1.原来和配置文件绑定的配置类是这样子
     *
     * @return
     * @ConfigurationProperties(prefix = "spring.cache")
     * public class CacheProperties
     * 2.要让他生效
     * @EnableConfigurationProperties(CacheProperties.class)
     */
    @Bean
    RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {


        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
//       config = config.entryTtl();
        config = config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericFastJsonRedisSerializer()));
        CacheProperties.Redis redisProperties = cacheProperties.getRedis();


        //将配置文件都生效
        if (redisProperties.getTimeToLive() != null) {
            config = config.entryTtl(redisProperties.getTimeToLive());
        }
        if (redisProperties.getKeyPrefix() != null) {
            config = config.prefixKeysWith(redisProperties.getKeyPrefix());
        }
        if (!redisProperties.isCacheNullValues()) {
            config = config.disableCachingNullValues();
        }
        if (!redisProperties.isUseKeyPrefix()) {
            config = config.disableKeyPrefix();
        }

        return config;

    }
}

3.常用注解

  • @Cacheable ：触发将数据保存到缓存的操作；
  • @CacheEvict : 触发将数据从缓存删除的操作；
  • @CachePut ：不影响方法执行更新缓存；
  • @Cacheing：组合以上多个操作；
  • @CacheConfig：在类级别共享缓存的相同配置；

4.业务实现

 /**
     * 查询所有的一级分类
     *
     * @return
     * @Cacheable: 当前方法的结果需要缓存 如果缓存中有方法不用调用，缓存中没有 调用方法 最后将方法的结果放进缓存
     * <p>
     * 默认行为：
     * 1) 如果缓存中有方法不用调用，缓存中没有 调用方法
     * 2) key是默认自动生成的，包含缓存名字::SimpleKey [](自主生成的key值)
     * 3）缓存的value的值，默认使用jdk序列化机制，将序列化后的数据存在redis
     * 4）默认时间-1（永不过期 ttl=-1）
     * <p>
     * <p>
     * <p>
     * 自定义操作（规范些）
     * 1.指定生成的缓存使用的key  key属性接受一个SpEl表达式
     * 2.指定缓存数据的存活时间   可以在配置文件中指定时间
     * 3.将数据保存为json格式
     * CacheAutoConfiguration
     * RedisCacheConfiguration
     *
     * springCache的不足：
     * 1） 读模式：
     *     缓存穿透：查询一个null数据 解决办法：缓存空数据 spring.cache.redis.cache-null-values=true
     *     缓存击穿：大量并发进来同时查询一个正好过期的数据  解决办法：加锁 默认无锁 sync = true（解决击穿）
     *     缓存雪崩：大量的key同时过期  解决办法：加随机时间 加过期时间  spring.cache.redis.time-to-live=3600000
     * 2） 写模式：（缓存与数据库的一致）
     *     读写加锁
     *     引入中间键canal，感知到mysql的更新去更新数据库
     *     读多写多 ：直接去数据库查询就行
     *
     *  总结：常规数据（读多写少的即时性一致性要求不高的）缓存的使用可以使用springCache，写模式只要缓存的数据有过期时间就足够了
     *       特殊数据：特殊设计
     *  原理：springCache有个CacheManager(RedisCacheManager)-->cache（RedisCache）组件-->cache负责缓存的读写
     *
     */
    //每一个需要缓存的数据都需要指定名字(缓存的分区)按照业务类型划分
    @Cacheable(value = {"category"}, key = "#root.method.name",sync = true)
    @Override
    public List<CategoryEntity> getLevel1Categorys() {
        System.out.println("getLevel1Categorys");
        long l = System.currentTimeMillis();

        List<CategoryEntity> categoryEntities = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", 0));
        System.out.println("消耗时间：" + (System.currentTimeMillis() - l));
        return categoryEntities;
    }

 

活着z
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
浅析Redis分布式锁
12-16
近期工作遇到需要业务场景如下,需要每天定时推送给另一系统一批数据,但是由于系统是集群部署的,会造成统一情况下任务争用的情况,所以需要增加分布式锁来保证一定时间范围内有一个Job来完成定时任务. 前期考虑的方案...
总线锁和缓存锁
qq_60236731的博客
06-09 854
第二个是缓存锁，我们知道cache中有三级缓存，一级和二级缓存是各个cpu内核私有的，第三级缓存是所有cpu内核共享的，缓存锁锁的是第三级缓存中该变量的缓存行，这个缓存锁并不是锁住这个缓存行不让其他cpu内核访问，而是拥有该锁的cpu内核才能修改该缓存行，如果它将来被修改了，修改的cpu内核会发出一个广播事件通知其他cpu内核说这个缓存行已经被修改了，是不正确的数据，麻烦你们重新去更新这个缓存行。最好的结果就是让A内核有锁即有这个权限，去修改该缓存行的数据，等A修改完再把这个锁的权限给B。
缓存(1)
sjjskshs的博客
11-06 235
放入缓存的数据格式本地缓存：放在本地内存中，先进行查询redis依赖redis本地配置方案lettuce可用数据传输量较大，但是会有后台内存溢出的bug，可进行包排除引入jedis。
Redis 分布式锁过期了，还没处理完怎么办？
最新发布
Javajdkbz的博客
06-11 604
为了防止死锁，我们会给分布式锁加一个过期时间，但是万一这个时间到了，我们业务逻辑还没处理完，怎么办？这是一个分布式应用里很常见到的需求，关于这个问题，有经验的程序员会怎么处理呢，今天的文章，V 哥来详细说一说，把这个问题彻底讲清楚。开干！首先，我们在设置过期时间时要结合业务场景去考虑，尽量设置一个比较合理的值，就是理论上正常处理的话，在这个过期时间内是一定能处理完毕的。之后，我们再来考虑对这个问题进行兜底设计。：额外起一个线程，定期检查线程是否还持有锁，如果有则延长过期时间。
zookeeper分布式锁
2401_83916435的博客
03-31 937
对于面试还是要好好准备的，尤其是有些问题还是很容易挖坑的，例如你为什么离开现在的公司（你当然不应该抱怨现在的公司有哪些不好的地方，更多的应该表明自己想要寻找更好的发展机会，自己的一些现实因素，比如对于我而言是现在应聘的公司离自己的家更近，又或者是自己工作到达了迷茫期，想跳出迷茫期等等）Java面试精选题、架构实战文档你的支持，我的动力；祝各位前程似锦，offer不断！《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！4)]Java面试精选题、架构实战文档。
缓存使用&加锁
ww_kobe的博客
04-24 602
SpringBoot整合resis、springcache分布式下加锁使用缓存
缓存锁缓存锁缓存锁
weixin_49390750的博客
02-20 181
缓存锁
分布式相关面试题汇总：分布式锁、分布式事务、分布式缓存、分布式ID
01-12
面试中，分布式锁、分布式事务和分布式缓存等概念是考察开发者技术能力的重要方面。下面将对这些主题进行详细阐述。 分布式锁是解决分布式环境下的资源争抢问题的关键工具。在单机系统中，锁的实现相对简单，但在...
缓存和分布式锁.pdf
06-21
缓存和分布式锁：缓存使用、缓存失效问题、、缓存数据一致性、分布式锁、、Redisson简介&整合、Spring Cache等内容
分布式锁三种实现方式及对比
12-14
本文将详细讨论三种常见的分布式锁实现方式：基于数据库、基于缓存（如Redis）以及基于Zookeeper，并对比它们的优缺点。 1. **基于数据库实现分布式锁** - **悲观锁**：使用`SELECT ... WHERE ... FOR UPDATE`...
redis和redisson实现分布式锁
05-26
分布式锁是分布式系统中解决并发控制的关键技术，它允许在多台服务器上共享资源并确保同一时刻只有一个客户端能访问特定的资源。Redis作为一款高性能的键值存储系统，常被用作实现分布式锁的工具，而Redisson是基于...
CPU结构、高速缓存、总线锁、缓存锁、缓存一致性协议、StoreBuffer、指令重排序、内存屏障
haoranhaoshi的博客
09-14 2390
CPU结构 任务管理器CPU部分右下中会展示高速缓存（L1、L2、L3）： 总线锁 总线层面解决数据一致性问题。 缓存锁 解决高速缓存中数据一致性问题（简称：缓存一致性问题）。避免多核CPU的线程中，复制的主内存数据不能及时同步。一个CPU内核的高速缓存中的数据更新，会让其他CPU内存的高速缓存中相同数据的缓存失效。然后此CPU内核的高速缓存中的数据同步到主内存，其他CPU内核的高速缓存中相同数据从主内存重新复制。 缓存一致性协议： MSI、MESI、MOSI... MES...
分布式锁-redisLock
weixin_39656626的博客
08-16 1187
文章目录RedisLockConfigRedisLock实现lua脚本测试 RedisLockConfig import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework
【Linux】解决缓存锁问题：无法获得锁 /var/lib/dpkg/lock-frontend
热门推荐
naihe_fish的博客
10-27 1万+
在你的情况下，进程1855（unattended-upgr）正在持有APT的锁。这是因为系统正在进行软件更新或升级。在进行这些操作时，APT会锁定相关文件以防止多个进程同时修改它们，以确保系统的稳定性和一致性。今天在运行apt-get update更新软件包后，突然发现安装新的软件出现了这个报错：正在等待缓存锁：无法获得锁 /var/lib/dpkg/lock-frontend。锁正由进程 1855（unattended-upgr）持有。1.等待一会即可：让进程1855完成其任务并释放APT锁。
分布式锁的实现方式——ACID数据库、缓存或者是zk
djph26741的博客
02-22 66
针对分布式锁的实现，目前比较常用的有以下几种方案： 基于数据库实现分布式锁 基于缓存（redis，memcached，tair）实现分布式锁 基于Zookeeper实现分布式锁 在分析这几种实现方案之前我们先来想一下，我们需要的分布式锁应该是怎么样的？（这里以方法锁为例，资源锁同理） 可以保证在分布式部署的应用集群中，同一个方法在同一时间只能被一台机器上的一个线程执行。...
浅谈 volatile
jcc4261的博客
12-05 674
在Java日常开发中,尤其是并发编程中,是一个高频使用的关键字,它提供了一种轻量级的同步机制(常用于和比较),用来修饰成员变量。 具有如下两大特性:1. 保证内存可见性 2. 禁止指令重排序我们先看一段代码： 从运行结果中可以看到，子线程t1中将flag修改为了true，但是主线程并没有读到t1线程修改后的值，导致主线程一直无法退出。所以多线程情况下修改共享变量会出现某一个线程修改后对其他线程不可见。在分析为什么不可见之前，我们先了解下Java内存模型JMM(和并发编程相关的模型)JMM即为JAVA 内
浅谈分布式锁--基于缓存（Redis，memcached，tair）实现篇
Eric的博客
09-19 2298
浅谈分布式锁--基于缓存（Redis，memcached，tair）实现篇： 一、Redis分布式锁 1、Redis实现分布式锁的原理： 1.利用setnx命令，即只有在某个key不存在情况才能set成功该key，这样就达到了多个进程并发去set同一个key，只有一个进程能set成功，如果设置了锁返回1， 已经有值没有设置成功返回0。 2.死锁问题，仅有一个setnx命令，r...
redis作为缓存和分布式锁的常见问题及解决方案
m0_37742400的博客
02-01 910
涵盖了redis作为缓存和分布式锁的常见问题和解决方案
分布式锁的3种实现（数据库、缓存、Zookeeper)
m0_61043185的博客
04-02 870
搞定算法，面试字节再不怕，有需要文章中分享的这些二叉树、链表、字符串、栈和队列等等各大面试高频知识点及解析最后再分享一份终极手撕架构的大礼包(学习笔记)：分布式+微服务+开源框架+性能优化笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）[外链图片转存中…(img-YubA5Zsl-1712064662221)]搞定算法，面试字节再不怕，有需要文章中分享的这些二叉树、链表、字符串、栈和队列等等各大面试高频知识点及解析。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值