什么是缓存穿透及其严重性
缓存穿透(Cache Penetration)是指当客户端请求的数据在缓存中不存在且数据库中也不存在时,导致每次请求都会直接穿透缓存层访问数据库的现象。这种情况通常发生在恶意攻击或业务逻辑异常时,例如攻击者故意请求大量不存在的key。缓存穿透会导致数据库承受巨大的查询压力,严重时可能引发数据库崩溃,影响整个系统的稳定性。
缓存穿透与缓存击穿(Cache Breakdown)和缓存雪崩(Cache Avalanche)有所不同:
缓存击穿
:指某个热点key在缓存过期的瞬间,大量请求同时涌入数据库
缓存雪崩
:指大量缓存key在同一时间过期,导致请求全部打到数据库
缓存穿透
:指请求的数据根本不存在,缓存无法起到拦截作用
在高并发场景下,缓存穿透的危害尤为严重。假设每秒有10,000个请求,每个请求都需要查询数据库,而数据库每秒只能处理2,000个查询,那么系统很快就会崩溃。因此,有效防止缓存穿透是构建高可用系统的关键环节。
Memcached在缓存穿透防护中的局限性
Memcached作为一款高性能的分布式内存缓存系统,在防止缓存穿透方面存在一些固有的局限性:
不支持持久化
:Memcached的数据完全存储在内存中,重启后所有数据丢失。这意味着我们无法通过持久化策略来保证缓存数据的长期有效性。
简单的键值存储
:Memcached只支持简单的key-value存储,不像Redis那样支持复杂的数据结构和丰富的操作。
缺乏内置的原子操作
:Memcached的CAS(Check-And-Set)机制虽然可以实现乐观锁,但在处理缓存重建时不如Redis的原子操作方便。
过期策略单一
:Memcached只支持基于时间的过期策略,不支持像Redis那样的懒删除策略。
尽管存在这些局限性,通过合理的架构设计和策略组合,我们仍然可以有效地使用Memcached来防止缓存穿透。
核心防护策略
1. 布隆过滤器(Bloom Filter)
布隆过滤器是防止缓存穿透最有效的手段之一。它是一种空间效率极高的概率性数据结构,用于判断一个元素是否在集合中。
布隆过滤器的工作原理
:
使用多个哈希函数将元素映射到一个位数组中
添加元素时,将多个哈希函数对应的位设置为1
查询时,检查所有哈希函数对应的位是否都为1
如果都为1,则元素可能存在(有误判率)
如果有任意一位为0,则元素一定不存在
布隆过滤器的优缺点
:
优点
:空间效率极高,查询时间复杂度为O(k),k为哈希函数个数
缺点
:存在误判率,不支持删除操作(标准布隆过滤器)
使用布隆过滤器防止缓存穿透的流程
:
在系统启动时,将数据库中所有存在的key加载到布隆过滤器中
当有请求到达时,先查询布隆过滤器
如果布隆过滤器判定key不存在,则直接返回,不查询数据库
如果布隆过滤器判定key可能存在,则继续查询缓存和数据库
布隆过滤器的实现示例
:
由于Memcached本身不支持布隆过滤器,我们需要在应用层实现或使用第三方库。以下是使用Python实现的简单布隆过滤器:
import mmh3
from bitarray import bitarray
class BloomFilter:
def __init__(self, size, hash_count):
“””
初始化布隆过滤器
:param size: 位数组大小
:param hash_count: 哈希函数个数
“””
self.size = size
self.hash_count = hash_count
self.bit_array = bitarray(size)
self.bit_array.setall(0)
def add(self, key):
“””
添加key到布隆过滤器
“””
for seed in range(self.hash_count):
index = mmh3.hash(key, seed) % self.size
self.bit_array[index] = 1
def might_contain(self, key):
“””
检查key是否可能存在
“””
for seed in range(self.hash_count):
index = mmh3.hash(key, seed) % self.size
if self.bit_array[index] == 0:
return False
return True
def delete(self, key):
“””
删除key(注意:这会破坏布隆过滤器的准确性)
“””
for seed in range(self.hash_count):
index = mmh3.hash(key, seed) % self.size
self.bit_array[index] = 0
# 使用示例
bf = BloomFilter(1000000, 7) # 100万大小,7个哈希函数
# 添加存在的key
existing_keys = [“user:1001”, “user:1002”, “product:5001”]
for key in existing_keys:
bf.add(key)
# 查询
print(bf.might_contain(“user:1001”)) # True
print(bf.might_contain(“user:9999″)) # False(可能误判为True)
在Memcached中存储布隆过滤器
:
由于布隆过滤器需要持久化,我们可以将其序列化后存储在Memcached中:
import pickle
import memcache
class MemcachedBloomFilter:
def __init__(self, mc_servers, key_prefix, size, hash_count):
self.mc = memcache.Client(mc_servers)
self.key_prefix = key_prefix
self.size = size
self.hash_count = hash_count
self.bf_key = f”{key_prefix}:bf”
def get_bloom_filter(self):
“””从Memcached获取布隆过滤器”””
data = self.mc.get(self.bf_key)
if data:
return pickle.loads(data)
else:
# 创建新的布隆过滤器
bf = BloomFilter(self.size, self.hash_count)
self._save_bf(bf)
return bf
def _save_bf(self, bf):
“””保存布隆过滤器到Memcached”””
data = pickle.dumps(bf)
self.mc.set(self.bf_key, data, 3600) # 1小时过期
def add(self, key):
“””添加key”””
bf = self.get_bloom_filter()
bf.add(key)
self._save_bf(bf)
def might_contain(self, key):
“””检查key是否存在”””
bf = self.get_bloom_filter()
return bf.might_contain(key)
# 使用示例
mc_bf = MemcachedBloomFilter([‘localhost:11211’], ‘app’, 1000000, 7)
mc_bf.add(“user:1001”)
print(mc_bf.might_contain(“user:1001”)) # True
2. 缓存空对象(Cache Null Objects)
缓存空对象是一种简单直接的防护策略,当查询到数据库中不存在的数据时,将一个特殊的空值缓存起来。
实现原理
:
当请求到达时,先查询缓存
如果缓存中存在数据(包括空值标记),直接返回
如果缓存中不存在,查询数据库
如果数据库中存在,缓存真实数据并返回
如果数据库中不存在,缓存空值标记并返回
空值标记的设计
:
使用特殊的key前缀,如
null:
或
empty:
设置较短的过期时间(如5-10分钟)
使用特殊的数据结构,如JSON字符串
{“__null__”: true}
代码示例
:
import json
import memcache
import time
class CacheService:
def __init__(self, mc_servers):
self.mc = memcache.Client(mc_servers)
self.null_prefix = “null:”
self.default_ttl = 3600 # 1小时
self.null_ttl = 300 # 5分钟
def get(self, key):
“””获取缓存数据”””
# 先尝试获取真实数据
value = self.mc.get(key)
if value is not None:
return value
# 检查是否是空值标记
null_key = self.null_prefix + key
null_value = self.mc.get(null_key)
if null_value is not None:
return None # 数据库中不存在
return None # 缓存未命中,需要查询数据库
def set(self, key, value, ttl=None):
“””设置缓存数据”””
if ttl is None:
ttl = self.default_ttl
self.mc.set(key, value, ttl)
def set_null(self, key):
“””设置空值标记”””
null_key = self.null_prefix + key
null_value = json.dumps({“__null__”: True, “timestamp”: time.time()})
self.mc.set(null_key, null_value, self.null_ttl)
def delete(self, key):
“””删除缓存”””
self.mc.delete(key)
self.mc.delete(self.null_prefix + key)
# 使用示例
cache = CacheService([‘localhost:11211’])
def get_user_info(user_id):
key = f”user:{user_id}”
# 1. 查询缓存
cached_data = cache.get(key)
if cached_data is not None:
return cached_data
# 2. 查询数据库
db_data = query_database(user_id)
if db_data:
# 3. 缓存真实数据
cache.set(key, db_data)
return db_data
else:
# 4. 缓存空值
cache.set_null(key)
return None
def query_database(user_id):
“””模拟数据库查询”””
# 实际项目中这里会是真实的数据库查询
mock_db = {“1001”: {“name”: “Alice”, “age”: 25}}
return mock_db.get(str(user_id))
3. 接口参数合法性校验
在缓存层之前增加参数合法性校验,可以拦截大量无效请求。
校验内容
:
参数类型和格式校验
参数范围校验(如ID不能为负数)
业务规则校验(如用户ID必须符合特定格式)
黑名单校验(拦截恶意IP或用户)
代码示例
:
import re
from functools import wraps
class Validator:
“””参数校验器”””
@staticmethod
def validate_user_id(user_id):
“””校验用户ID格式”””
if not user_id:
return False
if not isinstance(user_id, str):
return False
if not user_id.isdigit():
return False
if int(user_id) <= 0:
return False
if int(user_id) > 1000000: # 假设最大用户ID为100万
return False
return True
@staticmethod
def validate_product_id(product_id):
“””校验产品ID格式”””
if not product_id:
return False
if not isinstance(product_id, str):
return False
if not product_id.isdigit():
return False
if int(product_id) <= 0:
return False
return True
@staticmethod
def is_malicious_request(ip, user_id):
"""检测恶意请求"""
# 简单的频率限制检查
# 实际项目中可以使用Redis实现更复杂的限流
return False
def validate_params(param_name, validator_func):
"""参数校验装饰器"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
# 获取参数值
param_value = kwargs.get(param_name)
if param_value is None:
# 从args中查找
param_index = func.__code__.co_varnames.index(param_name)
if param_index < len(args):
param_value = args[param_index]
if param_value is None:
raise ValueError(f"参数 {param_name} 不能为空")
if not validator_func(param_value):
raise ValueError(f"参数 {param_name} 校验失败")
return func(*args, **kwargs)
return wrapper
return decorator
# 使用示例
@validate_params("user_id", Validator.validate_user_id)
def get_user_profile(user_id):
# 这里是业务逻辑
return f"User {user_id} profile"
# 测试
try:
print(get_user_profile(user_id="1001")) # 正常
print(get_user_profile(user_id="invalid")) # 抛出异常
except ValueError as e:
print(e)
4. 限流与熔断机制
限流可以防止突发的大流量对系统造成冲击,熔断机制可以在系统过载时快速失败。
限流策略
:
令牌桶算法
:以固定速率生成令牌,请求需要获取令牌才能处理
漏桶算法
:请求以任意速率进入,但以固定速率处理
计数器算法
:在固定时间窗口内限制请求次数
熔断机制
:
当错误率达到阈值时,自动切断请求
经过一段时间后,尝试恢复服务
代码示例
:
import time
import threading
from collections import deque
class TokenBucket:
"""令牌桶限流器"""
def __init__(self, capacity, refill_rate):
"""
:param capacity: 桶容量
:param refill_rate: 每秒生成的令牌数
"""
self.capacity = capacity
self.refill_rate = refill_rate
self.tokens = capacity
self.last_refill = time.time()
self.lock = threading.Lock()
def consume(self, tokens=1):
"""消耗令牌"""
with self.lock:
now = time.time()
# 补充令牌
elapsed = now - self.last_refill
self.tokens = min(self.capacity, self.tokens + elapsed * self.refill_rate)
self.last_refill = now
if self.tokens >= tokens:
self.tokens -= tokens
return True
return False
class CircuitBreaker:
“””熔断器”””
def __init__(self, failure_threshold=5, recovery_timeout=60):
self.failure_threshold = failure_threshold
self.recovery_timeout = recovery_timeout
self.failure_count = 0
self.last_failure_time = 0
self.state = “CLOSED” # CLOSED, OPEN, HALF_OPEN
self.lock = threading.Lock()
def call(self, func, *args, **kwargs):
“””执行函数,带熔断保护”””
with self.lock:
if self.state == “OPEN”:
if time.time() – self.last_failure_time > self.recovery_timeout:
self.state = “HALF_OPEN”
else:
raise Exception(“Circuit breaker is OPEN”)
try:
result = func(*args, **kwargs)
# 成功,重置失败计数
if self.state == “HALF_OPEN”:
self.state = “CLOSED”
self.failure_count = 0
return result
except Exception as e:
self.failure_count += 1
self.last_failure_time = time.time()
if self.failure_count >= self.failure_threshold:
self.state = “OPEN”
raise e
# 使用示例
token_bucket = TokenBucket(capacity=100, refill_rate=10)
circuit_breaker = CircuitBreaker(failure_threshold=3, recovery_timeout=30)
def get_data_with_protection(user_id):
# 限流检查
if not token_bucket.consume():
raise Exception(“Rate limit exceeded”)
# 熔断保护
def query():
return get_user_info(user_id)
return circuit_breaker.call(query)
实战解决方案:综合防护架构
架构设计
一个完整的Memcached缓存穿透防护架构应该包含多个层次:
客户端请求
↓
参数校验层(验证参数合法性)
↓
限流层(令牌桶/计数器)
↓
布隆过滤器层(快速判断key是否存在)
↓
缓存层(Memcached)
↓
空值缓存层(处理不存在的数据)
↓
数据库层(最终兜底)
完整代码实现
以下是一个完整的、生产级别的Memcached缓存穿透防护实现:
import json
import time
import threading
import memcache
import mmh3
from bitarray import bitarray
from functools import wraps
from typing import Optional, Any, Dict
# ==================== 布隆过滤器实现 ====================
class BloomFilter:
“””布隆过滤器”””
def __init__(self, size: int, hash_count: int):
self.size = size
self.hash_count = hash_count
self.bit_array = bitarray(size)
self.bit_array.setall(0)
def add(self, key: str):
for seed in range(self.hash_count):
index = mmh3.hash(key, seed) % self.size
self.bit_array[index] = 1
def might_contain(self, key: str) -> bool:
for seed in range(self.hash_count):
index = mmh3.hash(key, seed) % self.size
if self.bit_array[index] == 0:
return False
return True
class MemcachedBloomFilter:
“””Memcached持久化布隆过滤器”””
def __init__(self, mc_servers: list, key_prefix: str, size: int, hash_count: int):
self.mc = memcache.Client(mc_servers)
self.key_prefix = key_prefix
self.size = size
self.hash_count = hash_count
self.bf_key = f”{key_prefix}:bf”
self.lock = threading.Lock()
def get_bloom_filter(self) -> BloomFilter:
with self.lock:
data = self.mc.get(self.bf_key)
if data:
try:
return pickle.loads(data)
except:
pass
bf = BloomFilter(self.size, self.hash_count)
self._save_bf(bf)
return bf
def _save_bf(self, bf: BloomFilter):
data = pickle.dumps(bf)
self.mc.set(self.bf_key, data, 3600) # 1小时过期
def add(self, key: str):
bf = self.get_bloom_filter()
bf.add(key)
self._save_bf(bf)
def might_contain(self, key: str) -> bool:
bf = self.get_bloom_filter()
return bf.might_contain(key)
# ==================== 参数校验器 ====================
class ParamValidator:
“””参数校验器”””
# 正则表达式模式
USER_ID_PATTERN = re.compile(r’^\d{1,7}$’) # 1-7位数字
PRODUCT_ID_PATTERN = re.compile(r’^\d{1,8}$’) # 1-8位数字
@classmethod
def validate_user_id(cls, user_id: str) -> bool:
if not user_id or not isinstance(user_id, str):
return False
if not cls.USER_ID_PATTERN.match(user_id):
return False
if int(user_id) > 1000000: # 最大用户ID限制
return False
return True
@classmethod
def validate_product_id(cls, product_id: str) -> bool:
if not product_id or not isinstance(product_id, str):
return False
if not cls.PRODUCT_ID_PATTERN.match(product_id):
return False
return True
@classmethod
def validate_pagination(cls, page: int, page_size: int) -> bool:
if page < 1 or page > 1000: # 最多1000页
return False
if page_size < 1 or page_size > 100: # 每页最多100条
return False
return True
# ==================== 限流器 ====================
class TokenBucketRateLimiter:
“””令牌桶限流器”””
def __init__(self, capacity: int, refill_rate: float):
self.capacity = capacity
self.refill_rate = refill_rate
self.tokens = capacity
self.last_refill = time.time()
self.lock = threading.Lock()
def consume(self, tokens: int = 1) -> bool:
with self.lock:
now = time.time()
elapsed = now – self.last_refill
self.tokens = min(self.capacity, self.tokens + elapsed * self.refill_rate)
self.last_refill = now
if self.tokens >= tokens:
self.tokens -= tokens
return True
return False
class SlidingWindowRateLimiter:
“””滑动窗口限流器”””
def __init__(self, window_size_ms: int, max_requests: int):
self.window_size_ms = window_size_ms
self.max_requests = max_requests
self.requests = deque()
self.lock = threading.Lock()
def allow_request(self) -> bool:
with self.lock:
now = time.time() * 1000
# 移除窗口外的请求
while self.requests and self.requests[0] < now - self.window_size_ms:
self.requests.popleft()
if len(self.requests) < self.max_requests:
self.requests.append(now)
return True
return False
# ==================== 熔断器 ====================
class CircuitBreaker:
"""熔断器"""
def __init__(self, failure_threshold: int = 5, recovery_timeout: int = 60):
self.failure_threshold = failure_threshold
self.recovery_timeout = recovery_timeout
self.failure_count = 0
self.last_failure_time = 0
self.state = "CLOSED" # CLOSED, OPEN, HALF_OPEN
self.lock = threading.Lock()
def call(self, func, *args, **kwargs):
with self.lock:
if self.state == "OPEN":
if time.time() - self.last_failure_time > self.recovery_timeout:
self.state = “HALF_OPEN”
else:
raise Exception(“Circuit breaker is OPEN”)
try:
result = func(*args, **kwargs)
if self.state == “HALF_OPEN”:
self.state = “CLOSED”
self.failure_count = 0
return result
except Exception as e:
self.failure_count += 1
self.last_failure_time = time.time()
if self.failure_count >= self.failure_threshold:
self.state = “OPEN”
raise e
# ==================== 缓存服务 ====================
class CacheService:
“””Memcached缓存服务”””
def __init__(self, mc_servers: list):
self.mc = memcache.Client(mc_servers)
self.null_prefix = “null:”
self.default_ttl = 3600 # 1小时
self.null_ttl = 300 # 5分钟
def get(self, key: str) -> Optional[Any]:
# 先尝试获取真实数据
value = self.mc.get(key)
if value is not None:
return value
# 检查空值标记
null_key = self.null_prefix + key
null_value = self.mc.get(null_key)
if null_value is not None:
return None
return None
def set(self, key: str, value: Any, ttl: Optional[int] = None):
if ttl is None:
ttl = self.default_ttl
self.mc.set(key, value, ttl)
def set_null(self, key: str):
null_key = self.null_prefix + key
null_value = json.dumps({“__null__”: True, “timestamp”: time.time()})
self.mc.set(null_key, null_value, self.null_ttl)
def delete(self, key: str):
self.mc.delete(key)
self.mc.delete(self.null_prefix + key)
# ==================== 业务服务 ====================
class UserService:
“””用户服务”””
def __init__(self, cache: CacheService, bloom_filter: MemcachedBloomFilter):
self.cache = cache
self.bloom_filter = bloom_filter
self.rate_limiter = TokenBucketRateLimiter(capacity=100, refill_rate=10)
self.circuit_breaker = CircuitBreaker(failure_threshold=3, recovery_timeout=30)
def get_user_info(self, user_id: str) -> Optional[Dict]:
# 1. 参数校验
if not ParamValidator.validate_user_id(user_id):
raise ValueError(f”Invalid user_id: {user_id}”)
# 2. 限流检查
if not self.rate_limiter.consume():
raise Exception(“Rate limit exceeded”)
# 3. 布隆过滤器检查
cache_key = f”user:{user_id}”
if not self.bloom_filter.might_contain(cache_key):
print(f”布隆过滤器判定key不存在: {cache_key}”)
return None
# 4. 查询缓存
cached_data = self.cache.get(cache_key)
if cached_data is not None:
print(f”从缓存获取数据: {cache_key}”)
return cached_data
# 5. 熔断保护查询数据库
def query_db():
return self._query_database(user_id)
try:
db_data = self.circuit_breaker.call(query_db)
except Exception as e:
print(f”数据库查询失败: {e}”)
return None
if db_data:
# 6. 缓存真实数据
self.cache.set(cache_key, db_data)
print(f”缓存真实数据: {cache_key}”)
return db_data
else:
# 7. 缓存空值
self.cache.set_null(cache_key)
print(f”缓存空值: {cache_key}”)
return None
def _query_database(self, user_id: str) -> Optional[Dict]:
“””模拟数据库查询”””
# 实际项目中这里会是真实的数据库查询
mock_db = {
“1001”: {“name”: “Alice”, “age”: 25, “email”: “alice@example.com”},
“1002”: {“name”: “Bob”, “age”: 30, “email”: “bob@example.com”},
“1003”: {“name”: “Charlie”, “age”: 35, “email”: “charlie@example.com”}
}
# 模拟数据库查询延迟
time.sleep(0.01)
return mock_db.get(user_id)
def preload_bloom_filter(self, user_ids: list):
“””预热布隆过滤器”””
for user_id in user_ids:
cache_key = f”user:{user_id}”
self.bloom_filter.add(cache_key)
print(f”布隆过滤器预热完成,共加载 {len(user_ids)} 个key”)
# ==================== 使用示例 ====================
if __name__ == “__main__”:
# 初始化组件
mc_servers = [‘localhost:11211’]
cache = CacheService(mc_servers)
bloom_filter = MemcachedBloomFilter(mc_servers, ‘user_service’, 1000000, 7)
user_service = UserService(cache, bloom_filter)
# 预热布隆过滤器(在系统启动时执行)
existing_users = [“1001”, “1002”, “1003”]
user_service.preload_bloom_filter(existing_users)
# 测试场景
print(“\n=== 测试场景 ===”)
# 1. 查询存在的用户
print(“\n1. 查询存在的用户(1001):”)
result = user_service.get_user_info(“1001″)
print(f”结果: {result}”)
# 2. 再次查询(从缓存获取)
print(“\n2. 再次查询用户(1001):”)
result = user_service.get_user_info(“1001″)
print(f”结果: {result}”)
# 3. 查询不存在的用户(触发空值缓存)
print(“\n3. 查询不存在的用户(9999):”)
result = user_service.get_user_info(“9999″)
print(f”结果: {result}”)
# 4. 再次查询不存在的用户(从空值缓存获取)
print(“\n4. 再次查询不存在的用户(9999):”)
result = user_service.get_user_info(“9999″)
print(f”结果: {result}”)
# 5. 查询无效参数
print(“\n5. 查询无效参数:”)
try:
result = user_service.get_user_info(“invalid”)
except ValueError as e:
print(f”捕获异常: {e}”)
实战部署建议
1. Memcached配置优化
# 启动Memcached时的推荐参数
memcached -m 64 -p 11211 -c 1024 -t 4 -R 5 -b 1024
# 参数说明:
# -m 64: 分配64MB内存
# -p 11211: 监听端口
# -c 1024: 最大连接数
# -t 4: 使用4个线程
# -R 5: 每个连接最多处理5个请求
# -b 1024: listen队列大小
2. 监控指标
需要监控的关键指标:
缓存命中率
:目标应保持在95%以上
布隆过滤器误判率
:监控实际不存在的key被布隆过滤器判定为存在的比例
空值缓存比例
:空值缓存占总缓存的比例
数据库查询QPS
:监控是否还有穿透现象
限流触发次数
:监控系统压力
3. 缓存预热策略
在系统启动或低峰期,将热点数据预热到缓存中:
def cache_warmup():
“””缓存预热”””
# 1. 加载热点数据
hot_users = get_hot_users_from_db() # 从数据库获取热点用户
for user in hot_users:
cache_key = f”user:{user[‘id’]}”
cache.set(cache_key, user, 3600)
bloom_filter.add(cache_key)
# 2. 加载不存在的key到布隆过滤器
# 注意:这需要根据业务特点选择性加载
non_existent_keys = get_non_existent_keys()
for key in non_existent_keys:
bloom_filter.add(key)
4. 缓存更新策略
当数据库数据发生变化时,需要同步更新缓存:
def update_user_info(user_id: str, new_data: dict):
“””更新用户信息”””
cache_key = f”user:{user_id}”
# 1. 更新数据库
update_database(user_id, new_data)
# 2. 更新缓存
cache.set(cache_key, new_data)
# 3. 更新布隆过滤器(如果需要)
bloom_filter.add(cache_key)
# 4. 删除空值缓存(如果存在)
cache.delete(cache_key)
def delete_user_info(user_id: str):
“””删除用户信息”””
cache_key = f”user:{user_id}”
# 1. 删除数据库
delete_database(user_id)
# 2. 删除缓存
cache.delete(cache_key)
# 3. 注意:不要从布隆过滤器中删除(标准布隆过滤器不支持删除)
# 可以考虑使用Counting Bloom Filter支持删除
性能优化建议
1. 批量操作
使用Memcached的批量操作减少网络往返:
def batch_get_user_info(self, user_ids: list) -> dict:
“””批量获取用户信息”””
keys = [f”user:{uid}” for uid in user_ids]
# 批量查询缓存
cached_results = self.cache.mc.get_multi(keys)
# 找出需要查询数据库的key
missing_keys = []
results = {}
for key, value in cached_results.items():
if value is not None:
results[key] = value
else:
missing_keys.append(key)
# 批量查询数据库
if missing_keys:
db_results = self._batch_query_database(missing_keys)
for key, value in db_results.items():
if value:
self.cache.set(key, value)
results[key] = value
else:
self.cache.set_null(key)
return results
2. 连接池管理
import memcache
class PooledMemcacheClient:
“””连接池化的Memcached客户端”””
def __init__(self, servers, max_connections=10):
self.servers = servers
self.max_connections = max_connections
self.connection_pool = []
self.lock = threading.Lock()
def get_connection(self):
with self.lock:
if self.connection_pool:
return self.connection_pool.pop()
return memcache.Client(self.servers)
def release_connection(self, conn):
with self.lock:
if len(self.connection_pool) < self.max_connections:
self.connection_pool.append(conn)
else:
conn.close()
def execute(self, func, *args, **kwargs):
conn = self.get_connection()
try:
result = func(conn, *args, **kwargs)
return result
finally:
self.release_connection(conn)
总结
Memcached虽然在功能上不如Redis丰富,但通过合理的架构设计和策略组合,完全可以有效防止缓存穿透。关键要点:
多层防护
:参数校验 → 限流 → 布隆过滤器 → 缓存 → 空值缓存 → 数据库
布隆过滤器
:最有效的第一道防线,但需要注意误判率和持久化问题
空值缓存
:简单有效,但要控制好过期时间
限流熔断
:保护数据库的最后一道防线
监控告警
:及时发现和处理异常情况
通过这些策略的组合使用,可以将数据库的查询压力降低95%以上,即使面对恶意攻击也能保证系统的稳定运行。
# Memcached如何有效防止缓存穿透问题及实战解决方案
什么是缓存穿透及其严重性
缓存穿透(Cache Penetration)是指当客户端请求的数据在缓存中不存在且数据库中也不存在时,导致每次请求都会直接穿透缓存层访问数据库的现象。这种情况通常发生在恶意攻击或业务逻辑异常时,例如攻击者故意请求大量不存在的key。缓存穿透会导致数据库承受巨大的查询压力,严重时可能引发数据库崩溃,影响整个系统的稳定性。
缓存穿透与缓存击穿(Cache Breakdown)和缓存雪崩(Cache Avalanche)有所不同:
缓存击穿
:指某个热点key在缓存过期的瞬间,大量请求同时涌入数据库
缓存雪崩
:指大量缓存key在同一时间过期,导致请求全部打到数据库
缓存穿透
:指请求的数据根本不存在,缓存无法起到拦截作用
在高并发场景下,缓存穿透的危害尤为严重。假设每秒有10,000个请求,每个请求都需要查询数据库,而数据库每秒只能处理2,000个查询,那么系统很快就会崩溃。因此,有效防止缓存穿透是构建高可用系统的关键环节。
Memcached在缓存穿透防护中的局限性
Memcached作为一款高性能的分布式内存缓存系统,在防止缓存穿透方面存在一些固有的局限性:
不支持持久化
:Memcached的数据完全存储在内存中,重启后所有数据丢失。这意味着我们无法通过持久化策略来保证缓存数据的长期有效性。
简单的键值存储
:Memcached只支持简单的key-value存储,不像Redis那样支持复杂的数据结构和丰富的操作。
缺乏内置的原子操作
:Memcached的CAS(Check-And-Set)机制虽然可以实现乐观锁,但在处理缓存重建时不如Redis的原子操作方便。
过期策略单一
:Memcached只支持基于时间的过期策略,不支持像Redis那样的懒删除策略。
尽管存在这些局限性,通过合理的架构设计和策略组合,我们仍然可以有效地使用Memcached来防止缓存穿透。
核心防护策略
1. 布隆过滤器(Bloom Filter)
布隆过滤器是防止缓存穿透最有效的手段之一。它是一种空间效率极高的概率性数据结构,用于判断一个元素是否在集合中。
布隆过滤器的工作原理
:
使用多个哈希函数将元素映射到一个位数组中
添加元素时,将多个哈希函数对应的位设置为1
查询时,检查所有哈希函数对应的位是否都为1
如果都为1,则元素可能存在(有误判率)
如果有任意一位为0,则元素一定不存在
布隆过滤器的优缺点
:
优点
:空间效率极高,查询时间复杂度为O(k),k为哈希函数个数
缺点
:存在误判率,不支持删除操作(标准布隆过滤器)
使用布隆过滤器防止缓存穿透的流程
:
在系统启动时,将数据库中所有存在的key加载到布隆过滤器中
当有请求到达时,先查询布隆过滤器
如果布隆过滤器判定key不存在,则直接返回,不查询数据库
如果布隆过滤器判定key可能存在,则继续查询缓存和数据库
布隆过滤器的实现示例
:
由于Memcached本身不支持布隆过滤器,我们需要在应用层实现或使用第三方库。以下是使用Python实现的简单布隆过滤器:
import mmh3
from bitarray import bitarray
class BloomFilter:
def __init__(self, size, hash_count):
"""
初始化布隆过滤器
:param size: 位数组大小
:param hash_count: 哈希函数个数
"""
self.size = size
self.hash_count = hash_count
self.bit_array = bitarray(size)
self.bit_array.setall(0)
def add(self, key):
"""
添加key到布隆过滤器
"""
for seed in range(self.hash_count):
index = mmh3.hash(key, seed) % self.size
self.bit_array[index] = 1
def might_contain(self, key):
"""
检查key是否可能存在
"""
for seed in range(self.hash_count):
index = mmh3.hash(key, seed) % self.size
if self.bit_array[index] == 0:
return False
return True
def delete(self, key):
"""
删除key(注意:这会破坏布隆过滤器的准确性)
"""
for seed in range(self.hash_count):
index = mmh3.hash(key, seed) % self.size
self.bit_array[index] = 0
# 使用示例
bf = BloomFilter(1000000, 7) # 100万大小,7个哈希函数
# 添加存在的key
existing_keys = ["user:1001", "user:1002", "product:5001"]
for key in existing_keys:
bf.add(key)
# 查询
print(bf.might_contain("user:1001")) # True
print(bf.might_contain("user:9999")) # False(可能误判为True)
在Memcached中存储布隆过滤器
:
由于布隆过滤器需要持久化,我们可以将其序列化后存储在Memcached中:
import pickle
import memcache
class MemcachedBloomFilter:
def __init__(self, mc_servers, key_prefix, size, hash_count):
self.mc = memcache.Client(mc_servers)
self.key_prefix = key_prefix
self.size = size
self.hash_count = hash_count
self.bf_key = f"{key_prefix}:bf"
def get_bloom_filter(self):
"""从Memcached获取布隆过滤器"""
data = self.mc.get(self.bf_key)
if data:
return pickle.loads(data)
else:
# 创建新的布隆过滤器
bf = BloomFilter(self.size, self.hash_count)
self._save_bf(bf)
return bf
def _save_bf(self, bf):
"""保存布隆过滤器到Memcached"""
data = pickle.dumps(bf)
self.mc.set(self.bf_key, data, 3600) # 1小时过期
def add(self, key):
"""添加key"""
bf = self.get_bloom_filter()
bf.add(key)
self._save_bf(bf)
def might_contain(self, key):
"""检查key是否存在"""
bf = self.get_bloom_filter()
return bf.might_contain(key)
# 使用示例
mc_bf = MemcachedBloomFilter(['localhost:11211'], 'app', 1000000, 7)
mc_bf.add("user:1001")
print(mc_bf.might_contain("user:1001")) # True
2. 缓存空对象(Cache Null Objects)
缓存空对象是一种简单直接的防护策略,当查询到数据库中不存在的数据时,将一个特殊的空值缓存起来。
实现原理
:
当请求到达时,先查询缓存
如果缓存中存在数据(包括空值标记),直接返回
如果缓存中不存在,查询数据库
如果数据库中存在,缓存真实数据并返回
如果数据库中不存在,缓存空值标记并返回
空值标记的设计
:
使用特殊的key前缀,如
null:
或
empty:
设置较短的过期时间(如5-10分钟)
使用特殊的数据结构,如JSON字符串
{"__null__": true}
代码示例
:
import json
import memcache
import time
class CacheService:
def __init__(self, mc_servers):
self.mc = memcache.Client(mc_servers)
self.null_prefix = "null:"
self.default_ttl = 3600 # 1小时
self.null_ttl = 300 # 5分钟
def get(self, key):
"""获取缓存数据"""
# 先尝试获取真实数据
value = self.mc.get(key)
if value is not None:
return value
# 检查是否是空值标记
null_key = self.null_prefix + key
null_value = self.mc.get(null_key)
if null_value is not None:
return None # 数据库中不存在
return None # 缓存未命中,需要查询数据库
def set(self, key, value, ttl=None):
"""设置缓存数据"""
if ttl is None:
ttl = self.default_ttl
self.mc.set(key, value, ttl)
def set_null(self, key):
"""设置空值标记"""
null_key = self.null_prefix + key
null_value = json.dumps({"__null__": True, "timestamp": time.time()})
self.mc.set(null_key, null_value, self.null_ttl)
def delete(self, key):
"""删除缓存"""
self.mc.delete(key)
self.mc.delete(self.null_prefix + key)
# 使用示例
cache = CacheService(['localhost:11211'])
def get_user_info(user_id):
key = f"user:{user_id}"
# 1. 查询缓存
cached_data = cache.get(key)
if cached_data is not None:
return cached_data
# 2. 查询数据库
db_data = query_database(user_id)
if db_data:
# 3. 缓存真实数据
cache.set(key, db_data)
return db_data
else:
# 4. 缓存空值
cache.set_null(key)
return None
def query_database(user_id):
"""模拟数据库查询"""
# 实际项目中这里会是真实的数据库查询
mock_db = {"1001": {"name": "Alice", "age": 25}}
return mock_db.get(str(user_id))
3. 接口参数合法性校验
在缓存层之前增加参数合法性校验,可以拦截大量无效请求。
校验内容
:
参数类型和格式校验
参数范围校验(如ID不能为负数)
业务规则校验(如用户ID必须符合特定格式)
黑名单校验(拦截恶意IP或用户)
代码示例
:
import re
from functools import wraps
class Validator:
"""参数校验器"""
@staticmethod
def validate_user_id(user_id):
"""校验用户ID格式"""
if not user_id:
return False
if not isinstance(user_id, str):
return False
if not user_id.isdigit():
return False
if int(user_id) <= 0:
return False
if int(user_id) > 1000000: # 假设最大用户ID为100万
return False
return True
@staticmethod
def validate_product_id(product_id):
“””校验产品ID格式”””
if not product_id:
return False
if not isinstance(product_id, str):
return False
if not product_id.isdigit():
return False
if int(product_id) <= 0:
return False
return True
@staticmethod
def is_malicious_request(ip, user_id):
"""检测恶意请求"""
# 简单的频率限制检查
# 实际项目中可以使用Redis实现更复杂的限流
return False
def validate_params(param_name, validator_func):
"""参数校验装饰器"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
# 获取参数值
param_value = kwargs.get(param_name)
if param_value is None:
# 从args中查找
param_index = func.__code__.co_varnames.index(param_name)
if param_index < len(args):
param_value = args[param_index]
if param_value is None:
raise ValueError(f"参数 {param_name} 不能为空")
if not validator_func(param_value):
raise ValueError(f"参数 {param_name} 校验失败")
return func(*args, **kwargs)
return wrapper
return decorator
# 使用示例
@validate_params("user_id", Validator.validate_user_id)
def get_user_profile(user_id):
# 这里是业务逻辑
return f"User {user_id} profile"
# 测试
try:
print(get_user_profile(user_id="1001")) # 正常
print(get_user_profile(user_id="invalid")) # 抛出异常
except ValueError as e:
print(e)
4. 限流与熔断机制
限流可以防止突发的大流量对系统造成冲击,熔断机制可以在系统过载时快速失败。
限流策略
:
令牌桶算法
:以固定速率生成令牌,请求需要获取令牌才能处理
漏桶算法
:请求以任意速率进入,但以固定速率处理
计数器算法
:在固定时间窗口内限制请求次数
熔断机制
:
当错误率达到阈值时,自动切断请求
经过一段时间后,尝试恢复服务
代码示例
:
import time
import threading
from collections import deque
class TokenBucket:
"""令牌桶限流器"""
def __init__(self, capacity, refill_rate):
"""
:param capacity: 桶容量
:param refill_rate: 每秒生成的令牌数
"""
self.capacity = capacity
self.refill_rate = refill_rate
self.tokens = capacity
self.last_refill = time.time()
self.lock = threading.Lock()
def consume(self, tokens=1):
"""消耗令牌"""
with self.lock:
now = time.time()
# 补充令牌
elapsed = now - self.last_refill
self.tokens = min(self.capacity, self.tokens + elapsed * self.refill_rate)
self.last_refill = now
if self.tokens >= tokens:
self.tokens -= tokens
return True
return False
class CircuitBreaker:
“””熔断器”””
def __init__(self, failure_threshold=5, recovery_timeout=60):
self.failure_threshold = failure_threshold
self.recovery_timeout = recovery_timeout
self.failure_count = 0
self.last_failure_time = 0
self.state = “CLOSED” # CLOSED, OPEN, HALF_OPEN
self.lock = threading.Lock()
def call(self, func, *args, **kwargs):
“””执行函数,带熔断保护”””
with self.lock:
if self.state == “OPEN”:
if time.time() – self.last_failure_time > self.recovery_timeout:
self.state = “HALF_OPEN”
else:
raise Exception(“Circuit breaker is OPEN”)
try:
result = func(*args, **kwargs)
# 成功,重置失败计数
if self.state == “HALF_OPEN”:
self.state = “CLOSED”
self.failure_count = 0
return result
except Exception as e:
self.failure_count += 1
self.last_failure_time = time.time()
if self.failure_count >= self.failure_threshold:
self.state = “OPEN”
raise e
# 使用示例
token_bucket = TokenBucket(capacity=100, refill_rate=10)
circuit_breaker = CircuitBreaker(failure_threshold=3, recovery_timeout=30)
def get_data_with_protection(user_id):
# 限流检查
if not token_bucket.consume():
raise Exception(“Rate limit exceeded”)
# 熔断保护
def query():
return get_user_info(user_id)
return circuit_breaker.call(query)
实战解决方案:综合防护架构
架构设计
一个完整的Memcached缓存穿透防护架构应该包含多个层次:
客户端请求
↓
参数校验层(验证参数合法性)
↓
限流层(令牌桶/计数器)
↓
布隆过滤器层(快速判断key是否存在)
↓
缓存层(Memcached)
↓
空值缓存层(处理不存在的数据)
↓
数据库层(最终兜底)
完整代码实现
以下是一个完整的、生产级别的Memcached缓存穿透防护实现:
import json
import time
import threading
import memcache
import mmh3
from bitarray import bitarray
from functools import wraps
from typing import Optional, Any, Dict
# ==================== 布隆过滤器实现 ====================
class BloomFilter:
“””布隆过滤器”””
def __init__(self, size: int, hash_count: int):
self.size = size
self.hash_count = hash_count
self.bit_array = bitarray(size)
self.bit_array.setall(0)
def add(self, key: str):
for seed in range(self.hash_count):
index = mmh3.hash(key, seed) % self.size
self.bit_array[index] = 1
def might_contain(self, key: str) -> bool:
for seed in range(self.hash_count):
index = mmh3.hash(key, seed) % self.size
if self.bit_array[index] == 0:
return False
return True
class MemcachedBloomFilter:
“””Memcached持久化布隆过滤器”””
def __init__(self, mc_servers: list, key_prefix: str, size: int, hash_count: int):
self.mc = memcache.Client(mc_servers)
self.key_prefix = key_prefix
self.size = size
self.hash_count = hash_count
self.bf_key = f”{key_prefix}:bf”
self.lock = threading.Lock()
def get_bloom_filter(self) -> BloomFilter:
with self.lock:
data = self.mc.get(self.bf_key)
if data:
try:
return pickle.loads(data)
except:
pass
bf = BloomFilter(self.size, self.hash_count)
self._save_bf(bf)
return bf
def _save_bf(self, bf: BloomFilter):
data = pickle.dumps(bf)
self.mc.set(self.bf_key, data, 3600) # 1小时过期
def add(self, key: str):
bf = self.get_bloom_filter()
bf.add(key)
self._save_bf(bf)
def might_contain(self, key: str) -> bool:
bf = self.get_bloom_filter()
return bf.might_contain(key)
# ==================== 参数校验器 ====================
class ParamValidator:
“””参数校验器”””
# 正则表达式模式
USER_ID_PATTERN = re.compile(r’^\d{1,7}$’) # 1-7位数字
PRODUCT_ID_PATTERN = re.compile(r’^\d{1,8}$’) # 1-8位数字
@classmethod
def validate_user_id(cls, user_id: str) -> bool:
if not user_id or not isinstance(user_id, str):
return False
if not cls.USER_ID_PATTERN.match(user_id):
return False
if int(user_id) > 1000000: # 最大用户ID限制
return False
return True
@classmethod
def validate_product_id(cls, product_id: str) -> bool:
if not product_id or not isinstance(product_id, str):
return False
if not cls.PRODUCT_ID_PATTERN.match(product_id):
return False
return True
@classmethod
def validate_pagination(cls, page: int, page_size: int) -> bool:
if page < 1 or page > 1000: # 最多1000页
return False
if page_size < 1 or page_size > 100: # 每页最多100条
return False
return True
# ==================== 限流器 ====================
class TokenBucketRateLimiter:
“””令牌桶限流器”””
def __init__(self, capacity: int, refill_rate: float):
self.capacity = capacity
self.refill_rate = refill_rate
self.tokens = capacity
self.last_refill = time.time()
self.lock = threading.Lock()
def consume(self, tokens: int = 1) -> bool:
with self.lock:
now = time.time()
elapsed = now – self.last_refill
self.tokens = min(self.capacity, self.tokens + elapsed * self.refill_rate)
self.last_refill = now
if self.tokens >= tokens:
self.tokens -= tokens
return True
return False
class SlidingWindowRateLimiter:
“””滑动窗口限流器”””
def __init__(self, window_size_ms: int, max_requests: int):
self.window_size_ms = window_size_ms
self.max_requests = max_requests
self.requests = deque()
self.lock = threading.Lock()
def allow_request(self) -> bool:
with self.lock:
now = time.time() * 1000
# 移除窗口外的请求
while self.requests and self.requests[0] < now - self.window_size_ms:
self.requests.popleft()
if len(self.requests) < self.max_requests:
self.requests.append(now)
return True
return False
# ==================== 熔断器 ====================
class CircuitBreaker:
"""熔断器"""
def __init__(self, failure_threshold: int = 5, recovery_timeout: int = 60):
self.failure_threshold = failure_threshold
self.recovery_timeout = recovery_timeout
self.failure_count = 0
self.last_failure_time = 0
self.state = "CLOSED" # CLOSED, OPEN, HALF_OPEN
self.lock = threading.Lock()
def call(self, func, *args, **kwargs):
with self.lock:
if self.state == "OPEN":
if time.time() - self.last_failure_time > self.recovery_timeout:
self.state = “HALF_OPEN”
else:
raise Exception(“Circuit breaker is OPEN”)
try:
result = func(*args, **kwargs)
if self.state == “HALF_OPEN”:
self.state = “CLOSED”
self.failure_count = 0
return result
except Exception as e:
self.failure_count += 1
self.last_failure_time = time.time()
if self.failure_count >= self.failure_threshold:
self.state = “OPEN”
raise e
# ==================== 缓存服务 ====================
class CacheService:
“””Memcached缓存服务”””
def __init__(self, mc_servers: list):
self.mc = memcache.Client(mc_servers)
self.null_prefix = “null:”
self.default_ttl = 3600 # 1小时
self.null_ttl = 300 # 5分钟
def get(self, key: str) -> Optional[Any]:
# 先尝试获取真实数据
value = self.mc.get(key)
if value is not None:
return value
# 检查空值标记
null_key = self.null_prefix + key
null_value = self.mc.get(null_key)
if null_value is not None:
return None
return None
def set(self, key: str, value: Any, ttl: Optional[int] = None):
if ttl is None:
ttl = self.default_ttl
self.mc.set(key, value, ttl)
def set_null(self, key: str):
null_key = self.null_prefix + key
null_value = json.dumps({“__null__”: True, “timestamp”: time.time()})
self.mc.set(null_key, null_value, self.null_ttl)
def delete(self, key: str):
self.mc.delete(key)
self.mc.delete(self.null_prefix + key)
# ==================== 业务服务 ====================
class UserService:
“””用户服务”””
def __init__(self, cache: CacheService, bloom_filter: MemcachedBloomFilter):
self.cache = cache
self.bloom_filter = bloom_filter
self.rate_limiter = TokenBucketRateLimiter(capacity=100, refill_rate=10)
self.circuit_breaker = CircuitBreaker(failure_threshold=3, recovery_timeout=30)
def get_user_info(self, user_id: str) -> Optional[Dict]:
# 1. 参数校验
if not ParamValidator.validate_user_id(user_id):
raise ValueError(f”Invalid user_id: {user_id}”)
# 2. 限流检查
if not self.rate_limiter.consume():
raise Exception(“Rate limit exceeded”)
# 3. 布隆过滤器检查
cache_key = f”user:{user_id}”
if not self.bloom_filter.might_contain(cache_key):
print(f”布隆过滤器判定key不存在: {cache_key}”)
return None
# 4. 查询缓存
cached_data = self.cache.get(cache_key)
if cached_data is not None:
print(f”从缓存获取数据: {cache_key}”)
return cached_data
# 5. 熔断保护查询数据库
def query_db():
return self._query_database(user_id)
try:
db_data = self.circuit_breaker.call(query_db)
except Exception as e:
print(f”数据库查询失败: {e}”)
return None
if db_data:
# 6. 缓存真实数据
self.cache.set(cache_key, db_data)
print(f”缓存真实数据: {cache_key}”)
return db_data
else:
# 7. 缓存空值
self.cache.set_null(cache_key)
print(f”缓存空值: {cache_key}”)
return None
def _query_database(self, user_id: str) -> Optional[Dict]:
“””模拟数据库查询”””
# 实际项目中这里会是真实的数据库查询
mock_db = {
“1001”: {“name”: “Alice”, “age”: 25, “email”: “alice@example.com”},
“1002”: {“name”: “Bob”, “age”: 30, “email”: “bob@example.com”},
“1003”: {“name”: “Charlie”, “age”: 35, “email”: “charlie@example.com”}
}
# 模拟数据库查询延迟
time.sleep(0.01)
return mock_db.get(user_id)
def preload_bloom_filter(self, user_ids: list):
“””预热布隆过滤器”””
for user_id in user_ids:
cache_key = f”user:{user_id}”
self.bloom_filter.add(cache_key)
print(f”布隆过滤器预热完成,共加载 {len(user_ids)} 个key”)
# ==================== 使用示例 ====================
if __name__ == “__main__”:
# 初始化组件
mc_servers = [‘localhost:11211’]
cache = CacheService(mc_servers)
bloom_filter = MemcachedBloomFilter(mc_servers, ‘user_service’, 1000000, 7)
user_service = UserService(cache, bloom_filter)
# 预热布隆过滤器(在系统启动时执行)
existing_users = [“1001”, “1002”, “1003”]
user_service.preload_bloom_filter(existing_users)
# 测试场景
print(“\n=== 测试场景 ===”)
# 1. 查询存在的用户
print(“\n1. 查询存在的用户(1001):”)
result = user_service.get_user_info(“1001″)
print(f”结果: {result}”)
# 2. 再次查询(从缓存获取)
print(“\n2. 再次查询用户(1001):”)
result = user_service.get_user_info(“1001″)
print(f”结果: {result}”)
# 3. 查询不存在的用户(触发空值缓存)
print(“\n3. 查询不存在的用户(9999):”)
result = user_service.get_user_info(“9999″)
print(f”结果: {result}”)
# 4. 再次查询不存在的用户(从空值缓存获取)
print(“\n4. 再次查询不存在的用户(9999):”)
result = user_service.get_user_info(“9999″)
print(f”结果: {result}”)
# 5. 查询无效参数
print(“\n5. 查询无效参数:”)
try:
result = user_service.get_user_info(“invalid”)
except ValueError as e:
print(f”捕获异常: {e}”)
实战部署建议
1. Memcached配置优化
# 启动Memcached时的推荐参数
memcached -m 64 -p 11211 -c 1024 -t 4 -R 5 -b 1024
# 参数说明:
# -m 64: 分配64MB内存
# -p 11211: 监听端口
# -c 1024: 最大连接数
# -t 4: 使用4个线程
# -R 5: 每个连接最多处理5个请求
# -b 1024: listen队列大小
2. 监控指标
需要监控的关键指标:
缓存命中率
:目标应保持在95%以上
布隆过滤器误判率
:监控实际不存在的key被布隆过滤器判定为存在的比例
空值缓存比例
:空值缓存占总缓存的比例
数据库查询QPS
:监控是否还有穿透现象
限流触发次数
:监控系统压力
3. 缓存预热策略
在系统启动或低峰期,将热点数据预热到缓存中:
def cache_warmup():
“””缓存预热”””
# 1. 加载热点数据
hot_users = get_hot_users_from_db() # 从数据库获取热点用户
for user in hot_users:
cache_key = f”user:{user[‘id’]}”
cache.set(cache_key, user, 3600)
bloom_filter.add(cache_key)
# 2. 加载不存在的key到布隆过滤器
# 注意:这需要根据业务特点选择性加载
non_existent_keys = get_non_existent_keys()
for key in non_existent_keys:
bloom_filter.add(key)
4. 缓存更新策略
当数据库数据发生变化时,需要同步更新缓存:
def update_user_info(user_id: str, new_data: dict):
“””更新用户信息”””
cache_key = f”user:{user_id}”
# 1. 更新数据库
update_database(user_id, new_data)
# 2. 更新缓存
cache.set(cache_key, new_data)
# 3. 更新布隆过滤器(如果需要)
bloom_filter.add(cache_key)
# 4. 删除空值缓存(如果存在)
cache.delete(cache_key)
def delete_user_info(user_id: str):
“””删除用户信息”””
cache_key = f”user:{user_id}”
# 1. 删除数据库
delete_database(user_id)
# 2. 删除缓存
cache.delete(cache_key)
# 3. 注意:不要从布隆过滤器中删除(标准布隆过滤器不支持删除)
# 可以考虑使用Counting Bloom Filter支持删除
性能优化建议
1. 批量操作
使用Memcached的批量操作减少网络往返:
def batch_get_user_info(self, user_ids: list) -> dict:
“””批量获取用户信息”””
keys = [f”user:{uid}” for uid in user_ids]
# 批量查询缓存
cached_results = self.cache.mc.get_multi(keys)
# 找出需要查询数据库的key
missing_keys = []
results = {}
for key, value in cached_results.items():
if value is not None:
results[key] = value
else:
missing_keys.append(key)
# 批量查询数据库
if missing_keys:
db_results = self._batch_query_database(missing_keys)
for key, value in db_results.items():
if value:
self.cache.set(key, value)
results[key] = value
else:
self.cache.set_null(key)
return results
2. 连接池管理
import memcache
class PooledMemcacheClient:
“””连接池化的Memcached客户端”””
def __init__(self, servers, max_connections=10):
self.servers = servers
self.max_connections = max_connections
self.connection_pool = []
self.lock = threading.Lock()
def get_connection(self):
with self.lock:
if self.connection_pool:
return self.connection_pool.pop()
return memcache.Client(self.servers)
def release_connection(self, conn):
with self.lock:
if len(self.connection_pool) < self.max_connections:
self.connection_pool.append(conn)
else:
conn.close()
def execute(self, func, *args, **kwargs):
conn = self.get_connection()
try:
result = func(conn, *args, **kwargs)
return result
finally:
self.release_connection(conn)
总结
Memcached虽然在功能上不如Redis丰富,但通过合理的架构设计和策略组合,完全可以有效防止缓存穿透。关键要点:
多层防护
:参数校验 → 限流 → 布隆过滤器 → 缓存 → 空值缓存 → 数据库
布隆过滤器
:最有效的第一道防线,但需要注意误判率和持久化问题
空值缓存
:简单有效,但要控制好过期时间
限流熔断
:保护数据库的最后一道防线
监控告警
:及时发现和处理异常情况
通过这些策略的组合使用,可以将数据库的查询压力降低95%以上,即使面对恶意攻击也能保证系统的稳定运行。