【Redis学习系列】缓存概念和锁

redis.conf中配置 requirepass foobared：Redis密码设置。

redis.conf配置文件中的bind：白名单，允许哪个ip访问(对应服务器上面设置的安全组规则)。

缓存更新：

先删除缓存，再更新数据库(在没有更新数据库之前，但是缓存已删除，查询会直接查数据库会产生脏数据)。
先更新数据库，更新成功后再让缓存失效(低概率产生脏数据)。
更新数据的时候只更新缓存不更新数据库，然后同步异步去批量更新数据库(性能提高，数据的IO走缓存不走数据库，直接操作内存，但是数据也不是强一致)。

缓存穿透：

条件：是指查询一个数据库一定不存在的数据。正常的使用缓存流程大致是，数据查询先进行缓存查询，如果key不存在或者key已经过期，再对数据库进行查询，并把查询到的对象，放进缓存。如果数据库查询对象为空，则不放进缓存。
场景：如果查询一定不存在的对象。就会每次都去查询数据库，而每次查询都是空，每次又都不会进行缓存。假如有恶意攻击，就可以利用这个漏洞，对数据库造成压力，甚至压垮数据库。
处理：将这个缓存以及数据库中都查不到的key值设置null值存入到缓存中，这样之后这个key请求，能在缓存中拿到null值。
处理：布隆过滤器：在缓存之前加上一层BloomFilter，在查询的时候先去BloomFilter去查key是否存在，不存在直接返回，存在再走---->缓存----->DB。

缓存击穿（缓存雪崩）：场景：缓存同时失效，所有请求打到DB上，数据库压力过大宕机。

多线程之间使用互斥锁(用redis提供的setnx提供一个锁(其它方式也行)，让其它请求排队，只让一个请求打到DB，拿到数据设置缓存，后面请求继续走缓存)

Redis分布式锁：

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Component
@Slf4j
public class RedisLock {

    @Autowired
    private StringRedisTemplate redisTemplate;
    
    /**
     * 加锁
     * @param key    seckillId
     * @param value  当前时间+超时时间
     * @return
     */
    public boolean lock(String key, String value) {
        // 可以设置返回true
        Boolean isLock = redisTemplate.opsForValue().setIfAbsent(key, value);
        if (isLock) {
            return true;
        }
        String currentValue = redisTemplate.opsForValue().get(key);
        // 如果锁已经过期
        if (!StringUtils.isEmpty(currentValue)
                && Long.valueOf(currentValue) < System.currentTimeMillis()) {
            // 获取上一个锁的时间，并设置新锁的时间
            String oldValue = redisTemplate.opsForValue().getAndSet(key, value);
            if (!StringUtils.isEmpty(oldValue)
                    && oldValue.equals(currentValue)) {
                log.info("锁过期并返回true");
                return true;
            }
        }
        return false;
    }

    /**
     * 解锁
     * @param key
     * @return
     */
    public void unlock(String key, String value) {
        try {
            String currentValue = redisTemplate.opsForValue().get(key);
            if (!StringUtils.isEmpty(currentValue)
                    && currentValue.equals(value)) {
                redisTemplate.opsForValue().getOperations().delete(key);
            }
        } catch (Exception e) {
            log.error("redis分布式锁，解锁异常, {}",e.getMessage());
        }
    }
}

只有当线程拿到锁的时候才可执行try中的业务代码，并且在finally中我们对锁进行释放

long currentTimeMills = System.currentTimeMillis();
String redisLockValue = String.valueOf(currentTimeMills + RedisConstants.LOCK_EXPIRE_TIME);
final boolean lock = redisLock.lock(String.valueOf(seckillId), redisLockValue);
if (!lock) {
      throw new RuntimeException("人数过多，请稍后再试");
}
try {
      SeckillExecution execution = secPressureTestService.executeSeckill(seckillId);
      return Result.success(execution);
} catch (Exception e) {
      log.error("【执行秒杀错误】,message={}", e.getMessage());
      return Result.error(e.getMessage());
} finally {
      redisLock.unlock(String.valueOf(seckillId), redisLockValue);
}