import redis
import time
from functools import wraps

# 連接Redis
redis_client = redis.Redis(host='localhost', port=6379, db=0)

def get_data_from_cache_or_db(key, db_query_func, cache_ttl=3600):
    """從緩存獲取數(shù)據(jù)，若不存在則查詢數(shù)據(jù)庫并寫入緩存"""
    # 讀緩存
    cache_data = redis_client.get(key)
    if cache_data:
        return cache_data.decode('utf-8')  # 反序列化
    
    # 緩存未命中，查詢數(shù)據(jù)庫
    db_data = db_query_func()
    if db_data:
        # 寫入緩存（設(shè)置過期時(shí)間）
        redis_client.setex(key, cache_ttl, db_data)
    return db_data

# 示例：查詢用戶信息
def get_user_info(user_id):
    def query_db():
        # 實(shí)際項(xiàng)目中調(diào)用數(shù)據(jù)庫查詢
        return f"user:{user_id}:info"
    
    return get_data_from_cache_or_db(f"user:{user_id}", query_db)

def cache_with_lock(key, db_func, lock_ttl=10, cache_ttl=3600):
    """使用分布式鎖避免緩存擊穿（多個(gè)請(qǐng)求同時(shí)查詢數(shù)據(jù)庫）"""
    lock_key = f"lock:{key}"
    # 嘗試獲取鎖（SETNX：僅當(dāng)key不存在時(shí)設(shè)置）
    acquired = redis_client.set(
        lock_key, 
        "1", 
        nx=True,  # 不存在時(shí)才設(shè)置
        ex=lock_ttl  # 鎖過期時(shí)間，防止死鎖
    )
    
    if acquired:
        try:
            # 鎖獲取成功，查詢數(shù)據(jù)庫
            data = db_func()
            if data:
                redis_client.setex(key, cache_ttl, data)
            return data
        finally:
            # 釋放鎖（確保原子性，避免誤刪其他線程的鎖）
            redis_client.delete(lock_key)
    else:
        # 鎖被占用，等待重試或直接返回緩存（若有）
        time.sleep(0.1)  # 短暫休眠后重試
        return redis_client.get(key)

def update_data_and_cache(db_key, new_data):
    # 1. 更新數(shù)據(jù)庫
    update_db(db_key, new_data)
    # 2. 刪除緩存
    redis_client.delete(f"cache:{db_key}")
    # 3. 延時(shí)一段時(shí)間后再次刪除緩存（解決主從復(fù)制延遲問題）
    time.sleep(0.5)
    redis_client.delete(f"cache:{db_key}")

sentinel monitor mymaster 127.0.0.1 6379 2
sentinel down-after-milliseconds mymaster 5000

# 批量獲取
keys = ["user:1", "user:2", "user:3"]
results = redis_client.mget(keys)

# 管道批量操作
with redis_client.pipeline() as pipe:
    for key in keys:
        pipe.get(key)
    results = pipe.execute()

import redis
import json

class UserCache:
    def __init__(self, host='localhost', port=6379, db=0):
        self.redis_client = redis.Redis(host, port, db)
        self.cache_prefix = "user:"
        self.default_ttl = 3600  # 1小時(shí)
        
    def get_user(self, user_id):
        """獲取用戶信息（先查緩存，再查DB）"""
        cache_key = f"{self.cache_prefix}{user_id}"
        user_data = self.redis_client.get(cache_key)
        if user_data:
            return json.loads(user_data)
        
        # 緩存未命中，查詢DB（實(shí)際項(xiàng)目中替換為真實(shí)DB查詢）
        user_data = self._query_db(user_id)
        if user_data:
            self.redis_client.setex(
                cache_key, 
                self.default_ttl, 
                json.dumps(user_data)
            )
        return user_data
    
    def update_user(self, user_id, user_data):
        """更新用戶信息（先更新DB，再刪除緩存）"""
        # 1. 更新DB
        self._update_db(user_id, user_data)
        # 2. 刪除緩存（避免臟數(shù)據(jù)）
        cache_key = f"{self.cache_prefix}{user_id}"
        self.redis_client.delete(cache_key)
    
    def _query_db(self, user_id):
        """模擬數(shù)據(jù)庫查詢"""
        return {"id": user_id, "name": f"user_{user_id}", "create_time": time.time()}
    
    def _update_db(self, user_id, user_data):
        """模擬數(shù)據(jù)庫更新"""
        print(f"Updating user {user_id} in database...")