appendonly yes

#每次有数据修改发生时都会写入AOF文件，非常安全非常慢
appendfsync always
#每秒钟同步一次，该策略为AOF的缺省策略，够快可能会丢失1秒的数据
appendfsync everysec
#不主动fsync,由操作系统决定，更快，更不安全的方法
appendfsync no

优点

# 最大内存控制
maxmemory 最大内存阈值
maxmemory-policy 到达阈值的执行策略

当内存达到配置量时，会做一个内存压缩 ，这些配置都是压缩优化内存手段。

#配置字段最多512个
hash-max-zipmap-entries 512 
#配置value最大为64字节
hash-max-zipmap-value 64
#配置元素个数最多512个
list-max-ziplist-entries 512
#配置value最大为64字节
list-max-ziplist-value 64

#配置元素个数最多512个
set-max-intset-entries 512
#配置元素个数最多128个
zset-max-ziplist-entries 128 
#配置value最大为64字节
zset-max-ziplist-value 64

大小超出压缩范围，溢出后Redis将自动将其转换为正常大小，减少cpu的消耗

过期数据的处理策略

Reids的种淘汰策略：

主动处理（ redis 主动触发检测key是否过期）每秒执行10次。过程如下：

过期数据的计算和计算机本身的时间是有直接联系的。

LRU算法

 配置方式： maxmemory-samples 5

LFU算法

Redis内存回收策略

noeviction 客户端尝试执行会让更多内存被使用的命令直接报错
allkeys-lru 在所有key里执行LRU算法
volatile-lru 在所有已经过期的key里执行LRU算法
volatile-lfu 使用过期集在密钥中使用近似LFU进行驱逐
allkeys-lfu 使用近似LFU逐出任何键
allkeys-random 在所有key里随机回收
volatile-random 在已经过期的key里随机回收
volatile-ttl 回收已经过期的key，并且优先回收存活时间（TTL）较短的键

春节马上快到了，抢票回家的时刻也快来临了。通常我们会事先选择好一个车次然后疯狂更新车次信息，假设此时这般车的缓存刚好失效，可以想象会有多大的请求会直怼数据库。

 这会造成数据库的压力是非常大的，有可能导致数据库连接占满，有可能会影响其他功能，大量占用数据库连接，导致其他应用访问该DB数据库时，都会等待着，查询慢的情况。这就是缓存雪崩，缓存失效。

缓存雪崩风险

缓存雪崩：因为缓存服务挂掉或者热点缓存失效，从而导致海量请求去查询数据库，

导致数据库连接不够用或者数据库处理不过来，从而导致整个系统不可用。

 解决方案

• 在redis中设置过期时间，设置不一样的过期时间
• 不需要大量的请求来恢复缓存，采用互斥锁；把数据库不存在的数据，也缓存起来，短期过滤，过滤一些不存在的key.

•  拿到锁的线程负责更新缓存，其他请求读取备份缓存数据或者执行降级策略；
  备份缓存通常是不设置过期时间的，异步更新的缓存。
• 限流限次限频。
• 服务降级  对应用前端请求降级

使用锁的机制对商品进行 处理的形式

public class GoodsService2 {

    private final Logger logger = LoggerFactory.getLogger(GoodsService2.class);

    @Resource(name = "mainRedisTemplate")
    StringRedisTemplate mainRedisTemplate;

    @Autowired
    DatabaseService databaseService;

    Lock lock = new ReentrantLock();

    /**
     * 查询商品库存数
     *
     * @param goodsId 商品ID
     * @return 商品库存数
     */
    // @Cacheable 不管用什么样的方式，核心步骤 1，2，3
    public Object queryStock(final String goodsId) throws InterruptedException {
        // 1. 先从redis缓存中获取余票信息
    	String cacheKey = "goodsStock-"+goodsId;
        String value = mainRedisTemplate.opsForValue().get(cacheKey);
        if (value != null) {
            logger.warn(Thread.currentThread().getName() + "缓存中取得数据==============>" + value);
            return value;
        }

        // 2000 请求
        // 同步 一个个来
        lock.lock(); // 2000 线程 1个线程拿到，1999 等待排队
        try {
            // 再次获取缓存
            value = mainRedisTemplate.opsForValue().get(cacheKey);
            if (value != null) {
                logger.warn(Thread.currentThread().getName() + "缓存中取得数据==============>" + value);
                return value;
            }

            // 拿到锁 重建缓存
            // 2. 缓存中没有,则取数据库
            value = databaseService.queryFromDatabase(goodsId);
            System.out.println(Thread.currentThread().getName() + "从数据库中取得数据==============>" + value);

            // 3. 塞到缓存,120秒过期时间
            final String v = value;
            mainRedisTemplate.execute((RedisCallback<Boolean>) connection -> {
                return connection.setEx(cacheKey.getBytes(), 120, v.getBytes());
            });
        } finally {
            lock.unlock();
        }

        return value;
    }
}