缓存+分布式锁

1.使用redis作为缓存 springboot整合redis   lettuce,jedis操作redis底层客户端，spring再次封装redisTemplate

默认使用lettuce压测的时候容易产生out of direct memory,lettuce bug导致，可改用jedis

2.缓存穿透 ，查询一个不存在的数据，缓存中查不到，高并发下都去数据库查询，导致数据库崩溃

解决方案：null结果缓存，并加入短暂的过期时间

3.缓存雪崩：缓存中存在的大量数据 采用了相同的过期时间，导致某一时间缓存失效 请求全部到数据库 高并发下 导致数据库崩溃

解决方案：缓存失效时间基础上添加一个随机的值，使缓存不会大面积失效

4.缓存击穿：缓存中一条数据是热门数据，高并发下查询这条数据，等这条数据过期的时候，高并发到数据库导致数据库崩溃

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

怎样加锁：

(1).单体应用中加锁方式（本地锁，优点速度快）

只要是同一把锁，就能锁住需要这个锁的所有线程

synchronized(this): springboot所有组件在容器中都是单例的

在查询数据库的方法里面 加入synchronized(this){  得到锁以后，我们应该再去缓存中查询一次，如果没有再去查数据库，然后加入缓存} 代码块就能锁住该对象，或者synchronized直接加在操作数据库的方法上面

(2).分布式中加锁方式（分布式锁，缺点速度慢）

1.占分布式锁，去 redis占坑(原子加锁原子解锁)

public Map getLock(){

String uuid=UUID.randomUUID.toString();

//设置过期时间防止代码异常导致宕机  保证加锁和失效时间的原子性

Boolean lock=redisTemplate.opsForValue().setIfAbsent("lock",uuid,"300",TimeUnit.SECONOS);//占锁的时候同时设置nx ex

if(lock){

//占锁成功
try{

//执行任务查询数据库
}finally{
//释放锁
 String script = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
    Long result = redisTemplate.execute(redisScript, Arrays.aslist("lock"), uuid);
}

//释放

//String l=redisTemplate.opsForValue().get("lock");

//if(uuid.equals(l)){

//redisTemplate.delete("lock");//删除自己的锁

//}
//上面redis删锁不能保证原子性，需要使用下面的lua脚本

  

return 查询到的结果；

}else{

//失败，重试
try{
Thread.sleep(200);
}catch(){
}

return this.getLock();//自旋

}

}

总结:使用缓存正确步骤，1.空结果缓存，解决缓存穿透，2.设置过期时间（+随机值），解决缓存雪崩问题 3.加锁，解决缓存击穿问题

Redisson 作为分布式锁的框架

1.引入依赖

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

2.配置redisson

程序化配置

https://github.com/redisson/redisson/wiki/2.-%E9%85%8D%E7%BD%AE%E6%96%B9%E6%B3%95

@Configuration
public class myredissonconfig{
@Bean
public RedissonClient()throws IOException{
//创建配置（单节点）
    Config config = new Config();
      config.useSingleServer().setAddress("redis://myredisserver:6379");
    return Redisson.create(config);
}
}

可重入锁（Reentrant Lock）

基于Redis的Redisson分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。

//获取一把锁
RLock lock = redisson.getLock("anyLock");
// 加锁
lock.lock();
//阻塞式的等待，默认加的锁都是30s,如果业务时间超长，运行期间会自动续上30s（锁自动续期），不用担心业务时间超长，锁自动被删掉
//加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认在30s后自动删除

try{

System.out.println("加锁成功等待业务执行....."+thread.currentThread().getId());

Thread.sleep(30000);

}catch(){



lock.unlock();

}

读写锁（ReadWriteLock）用于两个以上服务操作同一个数据，不能用在同一个服务里面

基于Redis的Redisson分布式可重入读写锁RReadWriteLock Java对象实现了java.util.concurrent.locks.ReadWriteLock接口。其中读锁和写锁都继承了RLock接口。

分布式可重入读写锁允许同时有多个读锁和一个写锁处于加锁状态。

读加读锁写加写锁

读+读：相当于无锁，并发读，自会在redis中记录好，所有当前的读锁，他们都会加锁成功

写+读：等待写锁释放

写+写：阻塞方式

读+写：有读锁写也需要等待

只要有写的存在，都必须等待

// 保证一定能读到最新数据，修改期间，写锁是一个排他锁(独占)。读锁是一个共享锁
    //写锁没有释放，读锁必须等待
    @GetMapping("/write")
    @ResponseBody
    public String writeValue(){
        RReadWriteLock lock = redisson.getReadWriteLock("rw-lock");
        String s = "";
        RLock rLock = lock.writeLock();
        try {
            //1、改数据加写锁，读数据加读锁
            rLock.lock();
            s = UUID.randomUUID().toString();
            Thread.sleep(20000);
            redisTemplate.opsForValue().set("writeValue", s);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            rLock.unlock();
        }
        return s;
    }
 
    @GetMapping("/read")
    @ResponseBody
    public String readValue(){
        RReadWriteLock lock = redisson.getReadWriteLock("rw-lock");
        String s = "";
        // 加读锁
        RLock rLock = lock.readLock();
        rLock.lock();
        try {
            s = redisTemplate.opsForValue().get("writeValue");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rLock.unlock();
        }
        return s;
    }

 闭锁（CountDownLatch）

 信号量（Semaphore）

保证数据一致性  数据库和缓存

双写模式：修改数据后 重新放入缓存

失效模式：修改数据后 删除缓存数据

使用canal （阿里的数据库从库中间件）更新缓存 ，解决缓存数据一致性（待研究）

解决数据一致性的解决方案：缓存所有数据都有过期时间，数据过期后下一次查询会主动更新，读写数据时，加上分布式的读写锁

整合springCache简化缓存开发

1)引入依赖spring-boot-starter-cache  spring-boot-starter-data-redis

2)写配置

   （1）.自动配置了哪些

      CacheAuroConfiguration会导入 RedisCacheConfiguration;

      自动配置好了缓存管理器RedisCaceManager

     (2).

开启缓存功能：@EnableCaching

配置注解

 

指定缓存使用的key 注解上

@Cacheable(value={"category"},key="'levelcategory'")//字符串当key=category::levelcategory     

@Cacheable(value={"category"},key="#root.method.name")//方法名当key=category::getLevel1Categorys

设置缓存存活时间 配置文件中修改：spring.cache.redis.time-to-live=36000(毫秒单位)

 

 

import org.springframework.boot.autoconfigure.cache.CacheProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@EnableConfigurationProperties(CacheProperties.class)//用于配置文件生效
@Configuration
@EnableCaching
public class MyCacheConfig {
    @Bean
    RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();


//修改了k v 的序列化机制   使得缓存到redis中的为json字符串
        config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        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;
    }
}

 

失效模式下使用@cacheEvict(vlue="片区名"，key="要删除的名字")注解 实现缓存删除

1.同时进行多种缓存操作

@Cachint(evict={

@cacheEvict(vlue="片区名"，key="要删除的名字"),

@cacheEvict(vlue="片区名"，key="要删除的名字")

})

2.指定删除某个分区下的所有数据

@cacheEvict(vlue="片区名"，allEntries=true)

3.存储同一业务类型的数据，都可以指定成同一个分区。分区名就是默认前缀

双写模式下使用@CachPut

总结：常规数据（读多写少，即时性，一致性要求不高）完全可以使用Spring-cache

特殊数据：特殊设计  如读写锁，公平锁等