面试题：什么是缓存击穿、缓存穿透和缓存雪崩？它们分别会带来什么危害？该如何解决和预防？

import redis
import time
import uuid

# 连接到 Redis 服务器
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)

# 设置分布式锁的键和过期时间（秒）
LOCK_KEY = 'cache_击穿_lock'
LOCK_EXPIRE = 10  # 锁的有效期，可以根据需要调整

# 缓存的键和值（示例）
CACHE_KEY = 'some_hot_data'

def acquire_lock(redis_client, lock_key, lock_value, expire):
    """
    尝试获取分布式锁
    :param redis_client: Redis 客户端
    :param lock_key: 锁的键
    :param lock_value: 锁的值（通常是唯一标识符）
    :param expire: 锁的过期时间（秒）
    :return: 是否成功获取锁
    """
    while True:
        # 尝试设置锁，NX 表示只有键不存在时才设置，PX 表示过期时间（毫秒）
        result = redis_client.set(lock_key, lock_value, nx=True, px=expire * 1000)
        if result:
            return True
        # 休眠一小段时间后重试，避免忙等待
        time.sleep(0.01)

def release_lock(redis_client, lock_key, lock_value):
    """
    释放分布式锁
    :param redis_client: Redis 客户端
    :param lock_key: 锁的键
    :param lock_value: 锁的值（必须是获取锁时使用的相同值）
    :return: 是否成功释放锁
    """
    # 使用 Lua 脚本确保原子性释放锁
    lua_script = """
    if redis.call("get", KEYS[1]) == ARGV[1] then
        return redis.call("del", KEYS[1])
    else
        return 0
    end
    """
    redis_client.eval(lua_script, 1, lock_key, lock_value)
    return True

def get_data_with_cache_and_lock(redis_client, cache_key):
    """
    使用缓存、分布式锁和 Redis 事务获取数据
    :param redis_client: Redis 客户端
    :param cache_key: 缓存的键
    :return: 数据值或 None（如果数据不存在）
    """
    # 尝试从缓存中获取数据
    cache_value = redis_client.get(cache_key)
    if cache_value is not None:
        return cache_value.decode('utf-8')  # 假设数据是字符串类型

    # 尝试获取分布式锁
    lock_value = str(uuid.uuid4())
    if acquire_lock(redis_client, LOCK_KEY, lock_value, LOCK_EXPIRE):
        try:
            # 使用 Redis 事务确保原子性
            pipe = redis_client.pipeline(True)
            try:
                # 尝试再次从缓存中获取数据（防止其他客户端在获取锁后更新了缓存）
                pipe.watch(cache_key)
                cache_value = pipe.get(cache_key)
                if cache_value is not None:
                    pipe.unwatch()
                    pipe.reset()
                    return cache_value.decode('utf-8')

                # 从数据库中获取数据（模拟）
                # 在实际应用中，这里应该是访问数据库的逻辑
                data_from_db = "data_from_db"  # 假设从数据库中获取的数据

                # 更新缓存
                pipe.multi()
                pipe.set(cache_key, data_from_db)
                pipe.execute()

                # 返回从数据库中获取的数据
                return data_from_db

            except redis.WatchError:
                # 如果在事务执行过程中，缓存被其他客户端更新，则重新尝试获取数据
                pass

        finally:
            # 释放锁
            release_lock(redis_client, LOCK_KEY, lock_value)

    # 如果无法获取锁或缓存仍然为空，则返回 None（或根据业务逻辑返回默认值）
    return None

# 示例调用
data = get_data_with_cache_and_lock(redis_client, CACHE_KEY)
print(f"获取的数据: {data}")