Redis的缓存击穿、缓存穿透和缓存雪崩是什么？怎么预防？

local key =  ARGV[1]
local value = ARGV[2]
local addR = redis.call('set', key, value,'NX')
local expireR = redis.call('expire', key, 5000)
if addR and expireR  then
    return true
else
    return false
end

local lock = redis.call('set', key, value, 'NX', 'PX', 5000)

	static DefaultRedisScript<Boolean> SECKILL_SCRIPT;

    static {
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        //在resources目录下导入我们的脚本文件
        SECKILL_SCRIPT.setLocation(new ClassPathResource("lua/ntx.lua"));
        SECKILL_SCRIPT.setResultType(Boolean.class);
    }


    /**
     * 设置分布式锁
     */
    public boolean tryLock(String key) {


//      使用lua脚本保证原子性
        Boolean execute = (Boolean) redisTemplate.execute(
                SECKILL_SCRIPT,//这里就是我们上面静态代码块引入的脚步
                Collections.emptyList(),
                //这里要传key类型的参数,因为我上面写入redis缓存的key是用下面的第三部分参数args来拼出来的,
                //所以脚本是不需要key的,所以这里用方法传一个空集合,注意不要传null
                key.toString(), "1".toString()
        );
        return BooleanUtil.isTrue(execute);
    }
	/**
     * 解锁
     *
     * @param key
     */
    public void unlock(String key) {
            try{
                redisTemplate.delete(key);
            }catch (Exception e){
                log.error("删除失败");
            }

    }

public class ThreadUtils {
    // 设置延时任务线程
    public static void prolongTime(RedisTemplate redisTemplate, String key, int ttl) {
        new Thread(() -> {
            Time.sleep(4000);
            if (redisTemplate.hasKey(key)) {
                redisTemplate.expire(key, ttl, TimeUnit.SECONDS);
                // 重置过期时间后别忘记在设置一个延时任务
                prolongTime(redisTemplate, key, ttl);
            }
            System.out.println("已成功更新redis，防止缓存击穿！");
        }).start();
    }
}

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.0.1-jre</version>
</dependency>

package com.xiaow.movie.vo;

import com.google.common.hash.BloomFilter;
import com.xiaow.movie.service.VideoService;
import com.xiaow.movie.vo.aware.VideoBloomFilterAware;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @ClassName VideoBloomFilter
 * @Author xiaow
 * @DATE 2024/6/10 17:39
 **/
@Component
public class VideoBloomFilter implements VideoBloomFilterAware {

    @Autowired
    VideoService videoService;


    private BloomFilter<Long> filter;

    @Override
    public void setFilter(BloomFilter filter) {
        this.filter=filter;
    }

    public void initFilter() {
        // 将数据库中id导入到布隆过滤器中
        List<Integer> ids = videoService.getIds();
        for (Integer id : ids) {
            this.filter.put(Long.valueOf(id));
        }
    }

    public void addValue(Long id) {
       // 加入新的内容
        this.filter.put(id);
    }

    public Boolean exist(Long id) {
        // 判断是否存在
        return this.filter.mightContain(id);
    }
}

public interface VideoBloomFilterAware extends Aware {
    void setFilter(BloomFilter filter);

    void initFilter();
}

@Component
public class VideoBloomFilterPostProcessor implements BeanPostProcessor {
//  预计填充数量
    Long capacity = 10000L;
    // 错误比率
    double errorRate = 0.01;

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if(bean instanceof VideoBloomFilterAware){
            BloomFilter<Long> longBloomFilter = BloomFilter.create(Funnels.longFunnel(), capacity, errorRate);
            ((VideoBloomFilterAware) bean).setFilter(longBloomFilter);
            ((VideoBloomFilterAware) bean).initFilter();
        }
        return bean;
    }
}

	    Boolean exist = videoBloomFilter.exist(Long.valueOf(id));
        if (exist)
            // 存在则进行查询
            return Result.succ(videoService.getOneMutex(id));
        else
            // 不存在，直接返回
            return Result.fail("没有该视频");