mdbq 4.0.112__py3-none-any.whl → 4.0.114__py3-none-any.whl

mdbq/redis/redis_cache.py

@@ -5,30 +5,31 @@ Redis智能缓存系统
 主要功能：
 1. Redis缓存的CRUD操作
 2. 命名空间隔离
-3. 分布式锁防止缓存击穿
-4. 自动统计分析并提交到MySQL
+3. 智能TTL策略
+4. 专业统计分析并提交到MySQL
 5. 缓存健康检查和监控
-
+6. 热点键分析
+7. 响应时间分析
+8. 业务指标计算
 """
 
 import json
 import time
 import threading
 import socket
-from datetime import datetime, date
-from decimal import Decimal
-from uuid import UUID
-from typing import Optional, Dict, Any, List, Union, Callable
+import os
+import statistics
+import enum
+import re
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any, List, Callable
+from threading import Event
+from collections import defaultdict, deque
 import redis
 from mdbq.log import mylogger
 
-import enum
-from typing import Optional, Dict, Any, List, Union, Callable
-from concurrent.futures import ThreadPoolExecutor
-import asyncio
-from threading import Event
-import functools
 
+# 全局日志器
 logger = mylogger.MyLogger(
     logging_mode='file',
     log_level='info',
@@ -42,259 +43,340 @@ logger = mylogger.MyLogger(
 )
 
 
-class CacheSystemState(enum.Enum):
-    """缓存系统状态枚举"""
-    INITIALIZING = "initializing"
-    READY = "ready" 
-    MYSQL_READY = "mysql_ready"
-    ERROR = "error"
-
+class CacheStatsCollector:
+    """缓存统计收集器 - 单线程同步版本"""
+    
+    def __init__(self, enabled: bool = True, mysql_pool=None, config: dict = None):
+        self.enabled = enabled
+        self.mysql_pool = mysql_pool
+        self.config = config or {}
+        self.process_id = os.getpid()
+        self.instance_name = self.config.get('instance_name', 'default')
+        
+        # 统计数据
+        self.stats = {
+            'hits': 0,
+            'misses': 0,
+            'sets': 0,
+            'deletes': 0,
+            'errors': 0,
+            'total_operations': 0,
+            'start_time': time.time()
+        }
+        self._lock = threading.RLock()
+        self.response_times = deque(maxlen=1000)
+        self.namespace_stats = defaultdict(int)
+        
+        # 同步提交控制
+        self.submit_interval = self.config.get('submit_interval', 300)  # 每N次操作提交一次统计数据
+        self.last_submit_time = time.time()
+        self.min_submit_interval = self.config.get('min_submit_interval', 300)  # 最少N秒提交一次
 
-class MySQLDataEncoder(json.JSONEncoder):
-    """自定义JSON编码器，支持MySQL常见数据类型"""
-    def default(self, obj):
+    def record_operation(self, operation: str, response_time: float = 0, namespace: str = ""):
+        """记录操作统计"""
+        if not self.enabled:
+            return
+        
         try:
-            if isinstance(obj, datetime):
-                return obj.isoformat()
-            elif isinstance(obj, date):
-                return obj.isoformat()
-            elif isinstance(obj, Decimal):
-                # Decimal转换为字符串保持精度
-                return str(obj)
-            elif isinstance(obj, UUID):
-                return str(obj)
-            elif isinstance(obj, bytes):
-                # 二进制数据转换为base64
-                import base64
-                return base64.b64encode(obj).decode('utf-8')
-            elif isinstance(obj, (set, frozenset)):
-                # 集合类型转换为列表
-                return list(obj)
-            elif hasattr(obj, 'isoformat'):
-                # 其他日期时间类型
-                return obj.isoformat()
-            elif hasattr(obj, '__float__'):
-                # 数值类型
-                return float(obj)
-            elif hasattr(obj, '__str__'):
-                # 其他有字符串表示的对象
-                return str(obj)
-            elif hasattr(obj, '__dict__'):
-                # 处理其他对象，转换为字典
-                return obj.__dict__
+            with self._lock:
+                old_total = self.stats['total_operations']
+                
+                self.stats['total_operations'] += 1
+                self.stats[operation] = self.stats.get(operation, 0) + 1
+                
+                if response_time > 0:
+                    self.response_times.append(response_time)
+                
+                if namespace:
+                    self.namespace_stats[namespace] += 1
+                
+                # 检查是否需要提交统计数据（容错处理）
+                try:
+                    self._check_and_submit()
+                except Exception as submit_error:
+                    # 统计提交失败不应影响统计记录
+                    logger.error("统计数据提交检查失败，但统计记录继续", {
+                        'instance_name': self.instance_name,
+                        'process_id': self.process_id,
+                        'operation': operation,
+                        'submit_error': str(submit_error)
+                    })
+                
+                logger.debug("缓存操作统计已记录", {
+                    'operation': operation,
+                    'response_time_ms': round(response_time, 2),
+                    'namespace': namespace,
+                    'process_id': self.process_id,
+                    'old_total_operations': old_total,
+                    'new_total_operations': self.stats['total_operations']
+                })
         except Exception as e:
-            # 如果所有方法都失败，返回对象的字符串表示
-            return f"<{type(obj).__name__}: {str(obj)[:100]}>"
-        
-        return super().default(obj)
-
-
-class SmartTTLConfig:
-    """智能TTL配置策略"""
-    
-    # TTL策略映射表（秒）
-    TTL_STRATEGIES = {
-        # 数据库相关缓存
-        'sycm_database': 1800,      # 数据库列表：30分钟
-        'sycm_tables': 1200,        # 表列表：20分钟  
-        'sycm_table_data': 300,     # 表数据：5分钟
-        
-        # 用户会话相关
-        'user_session': 3600,       # 用户会话：1小时
-        'user_info': 1800,          # 用户信息：30分钟
-        
-        # 静态配置
-        'static_config': 86400,     # 静态配置：24小时
-        'system_config': 43200,     # 系统配置：12小时
-        
-        # API相关
-        'api_response': 600,        # API响应：10分钟
-        'api_cache': 900,           # API缓存：15分钟
-        
-        # 临时数据
-        'temp_data': 300,           # 临时数据：5分钟
-        'short_cache': 60,          # 短期缓存：1分钟
-    }
+            # 统计记录失败不应影响缓存操作
+            logger.error("统计记录失败，但缓存操作继续", {
+                'instance_name': self.instance_name,
+                'process_id': self.process_id,
+                'operation': operation,
+                'error': str(e)
+            })
     
-    @classmethod
-    def get_ttl(cls, namespace: str, default: int = 3600) -> int:
-        """
-        根据命名空间获取对应的TTL值
+    def _check_and_submit(self):
+        """检查并提交统计数据（同步）"""
+        if not self.mysql_pool:
+            return
+            
+        current_time = time.time()
+        time_since_last_submit = current_time - self.last_submit_time
+        should_submit = False
+        reason = ""
+        
+        # 重构后的提交逻辑：
+        # 1. 每N次操作提交一次，但每X秒内只能提交一次（防止频繁提交）
+        # 2. 每隔X秒提交一次，但必须满足N次操作
+        
+        if self.stats['total_operations'] % self.submit_interval == 0:
+            # 达到操作次数阈值
+            if time_since_last_submit >= self.min_submit_interval:
+                # 满足时间间隔要求，可以提交
+                should_submit = True
+                reason = f"达到操作次数阈值({self.submit_interval}次)且满足时间间隔({self.min_submit_interval}秒)"
+            else:
+                # 时间间隔不够，延迟提交
+                remaining_time = self.min_submit_interval - time_since_last_submit
+                logger.debug("操作次数达标但时间间隔不足，延迟提交", {
+                    'instance_name': self.instance_name,
+                    'process_id': self.process_id,
+                    'total_operations': self.stats['total_operations'],
+                    'time_since_last_submit': round(time_since_last_submit, 2),
+                    'remaining_time': round(remaining_time, 2)
+                })
+        elif time_since_last_submit >= self.min_submit_interval:
+            # 达到时间间隔阈值
+            if self.stats['total_operations'] >= self.submit_interval:
+                # 满足操作次数要求，可以提交
+                should_submit = True
+                reason = f"达到时间间隔阈值({self.min_submit_interval}秒)且满足操作次数({self.submit_interval}次)"
+            else:
+                # 操作次数不够，不提交
+                logger.debug("时间间隔达标但操作次数不足，暂不提交", {
+                    'instance_name': self.instance_name,
+                    'process_id': self.process_id,
+                    'total_operations': self.stats['total_operations'],
+                    'required_operations': self.submit_interval,
+                    'time_since_last_submit': round(time_since_last_submit, 2)
+                })
         
-        Args:
-            namespace: 缓存命名空间
-            default: 默认TTL值（秒）
+        if should_submit and self.stats['total_operations'] > 0:
+            try:
+                self._submit_to_mysql()
+                self.last_submit_time = current_time
+                logger.info("统计数据已同步提交", {
+                    'instance_name': self.instance_name,
+                    'process_id': self.process_id,
+                    'total_operations': self.stats['total_operations'],
+                    'time_since_last_submit': round(time_since_last_submit, 2),
+                    'reason': reason
+                })
+            except Exception as e:
+                logger.error("统计数据提交失败", {
+                    'instance_name': self.instance_name,
+                    'process_id': self.process_id,
+                    'error': str(e)
+                })
+    
+    def _submit_to_mysql(self):
+        """同步提交统计数据到MySQL"""
+        if not self.mysql_pool:
+            return
             
-        Returns:
-            int: TTL值（秒）
-        """
-        return cls.TTL_STRATEGIES.get(namespace, default)
+        stats_data = self.get_stats()
+        if not stats_data.get('enabled'):
+            return
+            
+        try:
+            connection = self.mysql_pool.connection()
+            with connection.cursor() as cursor:
+                # 选择数据库
+                cursor.execute(f"USE `{self.config.get('db_name', 'redis_stats')}`")
+                
+                # 插入统计数据
+                table_name = self.config.get('table_name', 'cache_performance')
+                insert_sql = f"""
+                INSERT INTO `{table_name}` (
+                    `日期`, `实例标识`, `主机名`, `进程ID`, `统计时间`,
+                    `缓存命中`, `缓存未命中`, `缓存设置`, `缓存删除`, `缓存错误`, `总操作数`,
+                    `命中率`, `平均响应时间`, `运行时间`, `命名空间统计`
+                ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+                """
+                
+                insert_data = (
+                    datetime.now().strftime('%Y-%m-%d'),
+                    f"{self.instance_name}_pid_{self.process_id}",
+                    socket.gethostname(),
+                    self.process_id,
+                    datetime.now(),
+                    stats_data['hits'],
+                    stats_data['misses'],
+                    stats_data['sets'],
+                    stats_data['deletes'],
+                    stats_data['errors'],
+                    stats_data['total_operations'],
+                    stats_data['hit_rate_percent'],
+                    stats_data['avg_response_time_ms'],
+                    stats_data['uptime_seconds'],
+                    json.dumps(stats_data['namespace_stats'], ensure_ascii=False)
+                )
+                
+                cursor.execute(insert_sql, insert_data)
+                connection.commit()
+                
+            connection.close()
+            
+        except Exception as e:
+            logger.error("MySQL同步提交失败", {
+                'instance_name': self.instance_name,
+                'process_id': self.process_id,
+                'error': str(e)
+            })
+            raise
     
-    @classmethod
-    def add_strategy(cls, namespace: str, ttl: int):
-        """
-        添加新的TTL策略
+    def get_stats(self) -> Dict[str, Any]:
+        """获取统计数据"""
+        if not self.enabled:
+            return {'enabled': False, 'message': '统计功能已禁用'}
         
-        Args:
-            namespace: 命名空间
-            ttl: TTL值（秒）
-        """
-        cls.TTL_STRATEGIES[namespace] = ttl
+        with self._lock:
+            uptime = time.time() - self.stats['start_time']
+            total_cache_ops = self.stats['hits'] + self.stats['misses']
+            hit_rate = (self.stats['hits'] / total_cache_ops * 100) if total_cache_ops > 0 else 0
+            avg_response_time = statistics.mean(self.response_times) if self.response_times else 0
+            
+            return {
+                'enabled': True,
+                'hits': self.stats['hits'],
+                'misses': self.stats['misses'],
+                'sets': self.stats['sets'],
+                'deletes': self.stats['deletes'],
+                'errors': self.stats['errors'],
+                'total_operations': self.stats['total_operations'],
+                'hit_rate_percent': round(hit_rate, 2),
+                'avg_response_time_ms': round(avg_response_time, 2),
+                'uptime_seconds': round(uptime, 2),
+                'namespace_stats': dict(self.namespace_stats),
+                'last_updated': datetime.now().isoformat(),
+                'process_id': self.process_id
+            }
     
-    @classmethod
-    def get_all_strategies(cls) -> Dict[str, int]:
-        """获取所有TTL策略"""
-        return cls.TTL_STRATEGIES.copy()
+    def reset_stats(self):
+        """重置统计数据"""
+        if not self.enabled:
+            return
+            
+        with self._lock:
+            self.stats = {
+                'hits': 0,
+                'misses': 0,
+                'sets': 0,
+                'deletes': 0,
+                'errors': 0,
+                'total_operations': 0,
+                'start_time': time.time()
+            }
+            self.response_times.clear()
+            self.namespace_stats.clear()
+            self.last_submit_time = time.time()
+
+
+class CacheSystemState(enum.Enum):
+    """缓存系统状态枚举"""
+    INITIALIZING = "initializing"
+    READY = "ready"
+    MYSQL_READY = "mysql_ready"
+    ERROR = "error"
+    SHUTDOWN = "shutdown"
 
 
 class CacheConfig:
-    """缓存系统配置类"""
-    
-    def __init__(self, db_name: str = "redis统计", table_name: str = "dpflask路由分析"):
-        # TTL配置（秒）
-        self.default_ttl = 3600  # 1小时
-        self.short_ttl = 300     # 5分钟
-        self.medium_ttl = 1800   # 30分钟
-        self.long_ttl = 7200     # 2小时
-        self.very_long_ttl = 86400  # 24小时
-        
-        # 缓存键前缀
-        self.cache_prefix = "smart_cache:"
-        self.stats_prefix = "cache_stats:"
-        self.lock_prefix = "cache_lock:"
-        
-        # 统计配置
-        self.stats_interval = 1800  # 统计间隔（秒）, 自动提交统计信息到MySQL的间隔
-        self.stats_retention = 7   # MySQL统计数据保留天数，超过此天数的数据将被自动删除
-        
-        # 性能配置
-        self.max_key_length = 250
-        self.max_value_size = 1024 * 1024  # 1MB
-        self.batch_size = 100
-        
-        # 热点键配置
-        self.max_hot_keys = 1000    # 最大热点键数量
-        self.hot_keys_cleanup_threshold = 800  # 热点键清理阈值
-        
-        # MySQL数据库配置
-        self.db_name = db_name
-        self.table_name = table_name
-        
-        # 锁配置
-        self.lock_timeout = 30     # 分布式锁超时时间
-        self.lock_retry_delay = 0.1  # 锁重试延迟
+    """缓存配置类"""
+    def __init__(self, **kwargs):
+        # 基础配置
+        self.default_ttl = kwargs.get('default_ttl', 3600)  # 默认过期时间(秒)
+        self.stats_interval = kwargs.get('stats_interval', 300)  # 每N次操作提交一次统计数据
+        self.stats_initial_delay = kwargs.get('stats_initial_delay', 300)  # 最少N秒提交一次
+        self.enable_stats = kwargs.get('enable_stats', True)  # 是否启用统计功能
+        self.max_value_size = kwargs.get('max_value_size', 10 * 1024 * 1024)  # 最大值大小(字节)
+        self.cache_prefix = kwargs.get('cache_prefix', 'cache')  # 缓存键前缀
+        self.enable_compression = kwargs.get('enable_compression', True)
+        
+        # 数据库配置
+        self.db_name = kwargs.get('db_name', 'redis_stats')
+        self.table_name = kwargs.get('table_name', 'cache_performance')
+        
+        # 智能TTL策略配置
+        self.enable_smart_ttl = kwargs.get('enable_smart_ttl', True)  # 启用智能TTL
+        self.ttl_min = kwargs.get('ttl_min', 60)  # 最小TTL(秒)
+        self.ttl_max = kwargs.get('ttl_max', 7200)  # 最大TTL(秒)
+        self.debug_ttl = kwargs.get('debug_ttl', False)  # TTL调试模式
+        
+        # 自定义TTL模式
+        self.custom_namespace_patterns = kwargs.get('custom_namespace_patterns', {})
+        self.custom_key_patterns = kwargs.get('custom_key_patterns', {})
 
 
 class SmartCacheSystem:
-    """智能缓存系统核心类"""
+    """智能缓存系统 - 单线程"""
     
-    def __init__(self, redis_client: redis.Redis, mysql_pool=None, instance_name: str = "default", 
-                 config: CacheConfig = None, db_name: str = None, table_name: str = None):
+    def __init__(self, redis_client: redis.Redis, mysql_pool=None, instance_name: str = "default", **config):
         self.redis_client = redis_client
         self.mysql_pool = mysql_pool
         self.instance_name = instance_name
+        self.config = CacheConfig(**config)
         
-        # 配置优先级：传入的config > 自定义db_name/table_name > 默认配置
-        if config:
-            self.config = config
-        elif db_name or table_name:
-            self.config = CacheConfig(
-                db_name=db_name or "redis统计",
-                table_name=table_name or "dpflask路由分析"
-            )
-        else:
-            self.config = CacheConfig()
-            
-        self.logger = logger
-        
-        # 状态管理
+        # 系统状态管理
         self._state = CacheSystemState.INITIALIZING
         self._ready_event = Event()
-        self._mysql_ready_event = Event()
-        
-        # 统计数据
-        self.stats = {
-            'hits': 0,
-            'misses': 0,
-            'sets': 0,
-            'deletes': 0,
-            'errors': 0,
-            'total_operations': 0,
-            'start_time': time.time(),
-            'response_times': []
-        }
         
-        # 热点键统计
-        self.hot_keys = {}
-        self.hot_keys_lock = threading.RLock()
-        
-        # 统计线程控制
-        self._stats_running = False
-        self._stats_thread = None
-        self._stats_lock = threading.RLock()
-        
-        # 使用线程池异步初始化
-        self._executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix=f"cache_{instance_name}")
+        # 直接初始化统计系统
+        self.stats_collector = None
+        if self.config.enable_stats:
+            self.stats_collector = CacheStatsCollector(
+                enabled=True,
+                mysql_pool=self.mysql_pool,
+                config={
+                    'instance_name': self.instance_name,
+                    'submit_interval': self.config.stats_interval,  # 每N次操作提交一次
+                    'min_submit_interval': 300,  # 最少N秒提交一次
+                    'table_name': self.config.table_name,
+                    'db_name': self.config.db_name
+                }
+            )
         
-        # 立即设置为基础就绪状态（Redis缓存可用）
+        # 初始化系统
+        self._initialize()
+    
+    def _initialize(self):
+        """初始化缓存系统"""
+        # 测试Redis连接
         if self._test_redis_connection():
             self._state = CacheSystemState.READY
             self._ready_event.set()
-        
-        # 异步初始化MySQL相关功能
-        self._executor.submit(self._initialize_mysql_features)
-        
-        self.logger.info("智能缓存系统初始化完成", {
-            'instance_name': self.instance_name,
-            'state': self._state.value,
-            'redis_ready': self._ready_event.is_set(),
-            'mysql_enabled': self.mysql_pool is not None
-        })
-    
-    def _initialize_mysql_features(self):
-        """在后台初始化MySQL相关功能"""
-        try:
-            if self.mysql_pool:
-                # 延迟初始化MySQL（给系统一些启动时间）
-                time.sleep(5)  # 等待5秒让主系统完全启动
-                
-                if self._init_mysql_db():
+            
+            # 如果启用统计且有MySQL连接，创建统计表
+            if self.config.enable_stats and self.mysql_pool:
+                try:
+                    self._create_simple_stats_table()
                     self._state = CacheSystemState.MYSQL_READY
-                    self._mysql_ready_event.set()
-                    
-                    # MySQL就绪后再启动统计线程
-                    self._start_stats_worker()
-                    
-                    self.logger.info("MySQL功能初始化完成", {
+                    logger.info("统计功能已启用", {
                         'instance_name': self.instance_name,
-                        'state': self._state.value
+                        'process_id': os.getpid()
                     })
-                else:
-                    self.logger.warning("MySQL初始化失败，缓存功能仍可正常使用")
-            else:
-                self.logger.info("未配置MySQL，跳过统计功能")
-                
-        except Exception as e:
+                except Exception as e:
+                    logger.error("统计表创建失败", {
+                        'instance_name': self.instance_name,
+                        'error': str(e)
+                    })
+        else:
             self._state = CacheSystemState.ERROR
-            self.logger.error(f"MySQL功能初始化异常: {e}")
-    
-    @property
-    def is_ready(self) -> bool:
-        """检查缓存系统是否就绪（Redis可用即为就绪）"""
-        return self._ready_event.is_set()
-    
-    @property 
-    def is_mysql_ready(self) -> bool:
-        """检查MySQL功能是否就绪"""
-        return self._mysql_ready_event.is_set()
-    
-    def wait_for_ready(self, timeout: float = 1.0) -> bool:
-        """等待缓存系统就绪（非阻塞，有超时）"""
-        return self._ready_event.wait(timeout)
-    
-    def wait_for_mysql_ready(self, timeout: float = 5.0) -> bool:
-        """等待MySQL功能就绪（非阻塞，有超时）"""
-        return self._mysql_ready_event.wait(timeout)
+            logger.error("Redis连接失败", {'instance_name': self.instance_name})
     
     def _test_redis_connection(self) -> bool:
         """测试Redis连接"""
@@ -302,652 +384,470 @@ class SmartCacheSystem:
             self.redis_client.ping()
             return True
         except Exception as e:
-            self.logger.error(f"Redis连接测试失败: {e}")
+            logger.error("Redis连接测试失败", {'error': str(e)})
             return False
     
-    def _init_mysql_db(self) -> bool:
-        """初始化MySQL数据库和表"""
+    def _create_simple_stats_table(self):
+        """创建统计表"""
         if not self.mysql_pool:
-            self.logger.warning("MySQL连接池未提供，统计功能将被禁用")
-            return False
+            return
         
         try:
-            # 设置连接超时，避免长时间阻塞
             connection = self.mysql_pool.connection()
-            # 设置查询超时（如果支持）
-            try:
-                connection.autocommit(False)  # 确保事务控制
-            except:
-                pass  # 忽略不支持的操作
+            with connection.cursor() as cursor:
+                # 创建数据库
+                cursor.execute(f"CREATE DATABASE IF NOT EXISTS `{self.config.db_name}` DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci")
+                cursor.execute(f"USE `{self.config.db_name}`")
                 
-            try:
-                with connection.cursor() as cursor:
-                    # 设置会话超时
-                    try:
-                        cursor.execute("SET SESSION wait_timeout = 30")
-                        cursor.execute("SET SESSION interactive_timeout = 30")
-                    except:
-                        pass  # 忽略不支持的操作
+                # 创建统计表
+                create_table_sql = f"""
+                CREATE TABLE IF NOT EXISTS `{self.config.table_name}` (
+                    `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+                    `日期` date NOT NULL COMMENT '统计日期',
+                    `实例标识` varchar(64) NOT NULL COMMENT '缓存实例标识',
+                    `主机名` varchar(100) NOT NULL COMMENT '服务器主机名',
+                    `进程ID` int NOT NULL COMMENT '进程ID',
+                    `统计时间` timestamp NOT NULL COMMENT '统计时间',
                     
-                    # 创建数据库
-                    cursor.execute(f"CREATE DATABASE IF NOT EXISTS `{self.config.db_name}` DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci")
-                    cursor.execute(f"USE `{self.config.db_name}`")
+                    -- 基础操作统计
+                    `缓存命中` bigint DEFAULT 0 COMMENT '缓存命中次数',
+                    `缓存未命中` bigint DEFAULT 0 COMMENT '缓存未命中次数',
+                    `缓存设置` bigint DEFAULT 0 COMMENT '缓存设置次数',
+                    `缓存删除` bigint DEFAULT 0 COMMENT '缓存删除次数',
+                    `缓存错误` bigint DEFAULT 0 COMMENT '缓存错误次数',
+                    `总操作数` bigint DEFAULT 0 COMMENT '总操作次数',
                     
-                    # 创建表（MySQL 8.4+兼容语法）
-                    create_table_sql = f"""
-                    CREATE TABLE IF NOT EXISTS `{self.config.table_name}` (
-                        `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
-                        `日期` date NOT NULL COMMENT '统计日期',
-                        `统计时间` datetime NOT NULL COMMENT '统计时间',
-                        `时间段` varchar(20) NOT NULL COMMENT '时间段标识',
-                        `缓存命中数` bigint DEFAULT 0 COMMENT '缓存命中次数',
-                        `缓存未命中数` bigint DEFAULT 0 COMMENT '缓存未命中次数',
-                        `缓存设置数` bigint DEFAULT 0 COMMENT '缓存设置次数',
-                        `缓存删除数` bigint DEFAULT 0 COMMENT '缓存删除次数',
-                        `缓存错误数` bigint DEFAULT 0 COMMENT '缓存错误次数',
-                        `命中率` decimal(5,2) DEFAULT 0.00 COMMENT '缓存命中率(%)',
-                        `总操作数` bigint DEFAULT 0 COMMENT '总操作次数',
-                        `平均响应时间` decimal(10,4) DEFAULT 0.0000 COMMENT '平均响应时间(ms)',
-                        `每秒操作数` decimal(10,2) DEFAULT 0.00 COMMENT '每秒操作数',
-                        `唯一键数量` int DEFAULT 0 COMMENT '唯一键数量',
-                        `系统运行时间` bigint DEFAULT 0 COMMENT '系统运行时间(秒)',
-                        `热点键统计` json DEFAULT NULL COMMENT '热点键统计信息',
-                        `服务器主机` varchar(100) DEFAULT NULL COMMENT '服务器主机名',
-                        `实例名称` varchar(100) DEFAULT NULL COMMENT '缓存实例名称',
-                        `创建时间` timestamp DEFAULT CURRENT_TIMESTAMP COMMENT '记录创建时间',
-                        `更新时间` timestamp DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '记录更新时间',
-                        PRIMARY KEY (`id`),
-                        KEY `idx_stats_date` (`日期`),
-                        KEY `idx_stats_time` (`统计时间`),
-                        KEY `idx_time_period` (`时间段`),
-                        KEY `idx_hit_rate` (`命中率`),
-                        KEY `idx_instance` (`实例名称`),
-                        KEY `idx_create_time` (`创建时间`)
-                    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='Redis缓存系统统计分析表'
-                    """
+                    -- 性能指标
+                    `命中率` decimal(5,2) DEFAULT 0.00 COMMENT '命中率百分比',
+                    `平均响应时间` decimal(10,2) DEFAULT 0.00 COMMENT '平均响应时间(毫秒)',
+                    `运行时间` bigint DEFAULT 0 COMMENT '运行时间(秒)',
                     
-                    cursor.execute(create_table_sql)
-                    connection.commit()
+                    -- 命名空间统计
+                    `命名空间统计` json COMMENT '命名空间统计详情',
                     
-                    self.logger.info("MySQL数据库表初始化成功", {
-                        'database': self.config.db_name,
-                        'table': self.config.table_name
-                    })
-                    return True
+                    -- 时间戳
+                    `创建时间` timestamp DEFAULT CURRENT_TIMESTAMP COMMENT '记录创建时间',
                     
-            finally:
-                connection.close()
+                    PRIMARY KEY (`id`),
+                    KEY `idx_日期` (`日期`),
+                    KEY `idx_实例时间` (`实例标识`, `统计时间`),
+                    KEY `idx_创建时间` (`创建时间`)
+                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='Redis缓存统计表'
+                """
                 
-        except Exception as e:
-            self.logger.error(f"MySQL数据库初始化失败: {e}")
-            # 不抛出异常，让系统继续运行
-            return False
-    
-    def _generate_cache_key(self, key: str, namespace: str = "") -> str:
-        """生成缓存键"""
-        if namespace:
-            return f"{self.config.cache_prefix}{namespace}:{key}"
-        return f"{self.config.cache_prefix}{key}"
-    
-    def _record_operation(self, operation: str, response_time: float = 0):
-        """记录操作统计"""
-        with self._stats_lock:
-            self.stats['total_operations'] += 1
-            if operation in self.stats:
-                self.stats[operation] += 1
-            if response_time > 0:
-                self.stats['response_times'].append(response_time)
-                # 只保留最近1000次操作的响应时间
-                if len(self.stats['response_times']) > 1000:
-                    self.stats['response_times'] = self.stats['response_times'][-1000:]
-    
-    def _record_hot_key(self, key: str, namespace: str = ""):
-        """记录热点键"""
-        cache_key = self._generate_cache_key(key, namespace)
-        with self.hot_keys_lock:
-            # 检查是否需要清理热点键（防止内存泄漏）
-            if len(self.hot_keys) >= self.config.hot_keys_cleanup_threshold:
-                # 保留访问次数最高的键，移除访问次数最少的键
-                sorted_keys = sorted(self.hot_keys.items(), key=lambda x: x[1], reverse=True)
-                # 保留前600个热点键，为新键留出空间
-                self.hot_keys = dict(sorted_keys[:600])
+                cursor.execute(create_table_sql)
+                connection.commit()
                 
-                self.logger.info("热点键内存清理", {
-                    '清理前数量': len(sorted_keys),
-                    '清理后数量': len(self.hot_keys),
-                    '清理阈值': self.config.hot_keys_cleanup_threshold
-                })
+            connection.close()
             
-            # 记录或更新热点键访问次数
-            self.hot_keys[cache_key] = self.hot_keys.get(cache_key, 0) + 1
+        except Exception as e:
+            logger.error("统计表初始化失败", {'error': str(e)})
+            raise
     
-    def _cache_operation(operation_name: str):
-        """缓存操作装饰器工厂"""
-        def decorator(func):
-            @functools.wraps(func)
-            def wrapper(self, *args, **kwargs):
-                start_time = time.time()
-                
-                # 检查系统是否就绪
-                if not self.is_ready:
-                    self._record_operation('errors')
-                    self.logger.warning(f"缓存系统未就绪，{operation_name}操作失败", {
-                        'state': self._state.value
-                    })
-                    return None if operation_name == 'get' else False
-                
-                try:
-                    result = func(self, *args, **kwargs)
-                    response_time = (time.time() - start_time) * 1000
-                    self._record_operation(operation_name, response_time)
-                    return result
-                    
-                except Exception as e:
-                    self._record_operation('errors')
-                    self.logger.error(f"缓存{operation_name}操作失败: {e}", {
-                        'args': args[:2] if len(args) > 2 else args,  # 避免记录过长的参数
-                        'operation': operation_name
-                    })
-                    return None if operation_name == 'get' else False
-                    
-            return wrapper
-        return decorator
+    @property
+    def is_ready(self) -> bool:
+        """检查系统是否就绪"""
+        return self._ready_event.is_set()
+    
+    @property
+    def is_mysql_ready(self) -> bool:
+        """检查MySQL是否就绪"""
+        return self._state == CacheSystemState.MYSQL_READY
     
-    @_cache_operation('get')
     def get(self, key: str, namespace: str = "", default=None) -> Any:
         """获取缓存值"""
-        cache_key = self._generate_cache_key(key, namespace)
-        
-        # 获取缓存值
-        value = self.redis_client.get(cache_key)
+        return self._get_with_stats(key, namespace, default)
+    
+    def _get_with_stats(self, key: str, namespace: str = "", default=None) -> Any:
+        """带统计的获取缓存值"""
+        if not self.is_ready:
+            return default
         
-        if value is not None:
-            # 缓存命中
-            self._record_hot_key(key, namespace)
+        start_time = time.time()
+        try:
+            cache_key = self._generate_cache_key(key, namespace)
+            value = self.redis_client.get(cache_key)
+            response_time = (time.time() - start_time) * 1000
             
-            try:
-                return json.loads(value.decode('utf-8'))
-            except (json.JSONDecodeError, UnicodeDecodeError):
-                return value.decode('utf-8')
-        else:
-            # 缓存未命中
+            if value is not None:
+                # 缓存命中
+                if self.stats_collector:
+                    self.stats_collector.record_operation('hits', response_time, namespace)
+                try:
+                    return json.loads(value.decode('utf-8'))
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    return value.decode('utf-8')
+            else:
+                # 缓存未命中
+                if self.stats_collector:
+                    self.stats_collector.record_operation('misses', response_time, namespace)
+                return default
+                
+        except Exception as e:
+            response_time = (time.time() - start_time) * 1000
+            if self.stats_collector:
+                self.stats_collector.record_operation('errors', response_time, namespace)
+            logger.error("缓存获取失败", {
+                'key': key,
+                'namespace': namespace,
+                'error': str(e)
+            })
             return default
     
-    @_cache_operation('set')
-    def set(self, key: str, value: Any, ttl: int = None, namespace: str = "") -> bool:
+    def set(self, key: str, value: Any, ttl: Optional[int] = None, namespace: str = "") -> bool:
         """设置缓存值"""
-        cache_key = self._generate_cache_key(key, namespace)
-        
-        # 使用智能TTL策略
-        if ttl is None:
-            ttl = SmartTTLConfig.get_ttl(namespace, self.config.default_ttl)
-        
-        # 序列化值
-        if isinstance(value, (dict, list, tuple)):
-            serialized_value = json.dumps(value, ensure_ascii=False, sort_keys=True, cls=MySQLDataEncoder)
-        else:
-            serialized_value = str(value)
-        
-        # 检查值大小
-        if len(serialized_value.encode('utf-8')) > self.config.max_value_size:
-            self.logger.warning(f"缓存值过大，跳过设置: {len(serialized_value)} bytes")
+        return self._set_with_stats(key, value, ttl, namespace)
+    
+    def _set_with_stats(self, key: str, value: Any, ttl: Optional[int] = None, namespace: str = "") -> bool:
+        """带统计的设置缓存值"""
+        if not self.is_ready:
             return False
         
-        # 设置缓存
-        result = self.redis_client.setex(cache_key, ttl, serialized_value)
-        
-        # 记录TTL策略使用情况
-        if namespace and ttl != self.config.default_ttl:
-            self.logger.debug("使用智能TTL策略", {
-                'namespace': namespace,
-                'ttl': ttl,
-                'key': key[:50] + "..." if len(key) > 50 else key
-            })
-        
-        return bool(result)
-    
-    def delete(self, key: str, namespace: str = "") -> bool:
-        """删除缓存值"""
         start_time = time.time()
-        
         try:
             cache_key = self._generate_cache_key(key, namespace)
-            result = self.redis_client.delete(cache_key)
+            
+            # 智能TTL策略
+            if ttl is None:
+                ttl = self._get_smart_ttl(namespace, key, len(json.dumps(value, ensure_ascii=False, default=str)))
+            
+            # 序列化值
+            if isinstance(value, (dict, list)):
+                serialized_value = json.dumps(value, ensure_ascii=False, default=str)
+            else:
+                serialized_value = str(value)
+            
+            # 检查值大小
+            value_size = len(serialized_value.encode('utf-8'))
+            if value_size > self.config.max_value_size:
+                if self.stats_collector:
+                    self.stats_collector.record_operation('errors', 0, namespace)
+                logger.warning("缓存值过大，跳过设置", {
+                    'key': key,
+                    'size': len(serialized_value),
+                    'max_size': self.config.max_value_size
+                })
+                return False
+            
+            result = self.redis_client.setex(cache_key, ttl, serialized_value)
             response_time = (time.time() - start_time) * 1000
             
-            self._record_operation('deletes', response_time)
+            if self.stats_collector:
+                self.stats_collector.record_operation('sets', response_time, namespace)
             return bool(result)
             
         except Exception as e:
-            self._record_operation('errors')
-            self.logger.error(f"缓存删除失败: {e}", {
+            response_time = (time.time() - start_time) * 1000
+            if self.stats_collector:
+                self.stats_collector.record_operation('errors', response_time, namespace)
+            logger.error("缓存设置失败", {
                 'key': key,
-                'namespace': namespace
+                'namespace': namespace,
+                'error': str(e)
             })
             return False
     
-    def exists(self, key: str, namespace: str = "") -> bool:
-        """检查缓存键是否存在"""
+    def delete(self, key: str, namespace: str = "") -> bool:
+        """删除缓存值"""
+        return self._delete_with_stats(key, namespace)
+    
+    def _delete_with_stats(self, key: str, namespace: str = "") -> bool:
+        """带统计的删除缓存值"""
+        if not self.is_ready:
+            return False
+        
+        start_time = time.time()
         try:
             cache_key = self._generate_cache_key(key, namespace)
-            return bool(self.redis_client.exists(cache_key))
+            result = self.redis_client.delete(cache_key)
+            response_time = (time.time() - start_time) * 1000
+            if self.stats_collector:
+                self.stats_collector.record_operation('deletes', response_time, namespace)
+            return bool(result)
+            
         except Exception as e:
-            self.logger.error(f"缓存存在性检查失败: {e}")
+            response_time = (time.time() - start_time) * 1000
+            if self.stats_collector:
+                self.stats_collector.record_operation('errors', response_time, namespace)
+            logger.error("缓存删除失败", {
+                'key': key,
+                'namespace': namespace,
+                'error': str(e)
+            })
             return False
     
     def clear_namespace(self, namespace: str) -> int:
         """清除指定命名空间的所有缓存"""
+        if not self.is_ready:
+            return 0
+        
         try:
-            pattern = f"{self.config.cache_prefix}{namespace}:*"
+            pattern = f"{self.config.cache_prefix}:{namespace}:*"
             keys = self.redis_client.keys(pattern)
             
             if keys:
                 deleted = self.redis_client.delete(*keys)
-                self.logger.info(f"清除命名空间缓存: {namespace}, 删除键数: {deleted}")
                 return deleted
             return 0
             
         except Exception as e:
-            self.logger.error(f"清除命名空间缓存失败: {e}")
+            logger.error("清除命名空间失败", {
+                'namespace': namespace,
+                'error': str(e)
+            })
             return 0
     
-    def get_stats(self) -> Dict[str, Any]:
-        """获取缓存统计信息"""
-        with self._stats_lock:
-            total_ops = self.stats['total_operations']
-            hits = self.stats['hits']
+    def _generate_cache_key(self, key: str, namespace: str = "") -> str:
+        """生成缓存键"""
+        if namespace:
+            return f"{self.config.cache_prefix}:{namespace}:{key}"
+        return f"{self.config.cache_prefix}:{key}"
+    
+    def _get_smart_ttl(self, namespace: str, key: str = "", data_size: int = 0) -> int:
+        """智能TTL策略 - 通用版本
+        
+        基于多种因素智能计算TTL：
+        1. 命名空间模式匹配
+        2. 数据类型推断
+        3. 数据大小考虑
+        4. 访问频率预测
+        """
+        
+        # 如果禁用智能TTL，直接返回默认值
+        if not self.config.enable_smart_ttl:
+            return self.config.default_ttl
+        
+        # 1. 基于命名空间模式的智能匹配
+        namespace_patterns = {
+            # 数据库相关 - 变化频率低，TTL较长
+            r'.*database.*|.*db.*|.*schema.*': 1800,  # 30分钟
             
-            # 计算命中率
-            hit_rate = (hits / total_ops * 100) if total_ops > 0 else 0
+            # 表结构相关 - 变化频率低，TTL较长  
+            r'.*table.*|.*column.*|.*field.*': 1200,  # 20分钟
             
-            # 计算平均响应时间
-            response_times = self.stats['response_times']
-            avg_response_time = sum(response_times) / len(response_times) if response_times else 0
+            # 数据查询相关 - 变化频率中等，TTL中等
+            r'.*data.*|.*query.*|.*result.*': 300,    # 5分钟
             
-            # 计算运行时间
-            uptime = time.time() - self.stats['start_time']
+            # 用户会话相关 - 变化频率高，TTL较短
+            r'.*session.*|.*user.*|.*auth.*': 900,    # 15分钟
             
-            # 计算每秒操作数
-            ops_per_second = total_ops / uptime if uptime > 0 else 0
+            # 配置相关 - 变化频率很低，TTL很长
+            r'.*config.*|.*setting.*|.*param.*': 3600, # 1小时
             
-            # 获取热点键（前10个）
-            with self.hot_keys_lock:
-                top_hot_keys = sorted(self.hot_keys.items(), key=lambda x: x[1], reverse=True)[:10]
+            # 统计相关 - 变化频率中等，TTL中等
+            r'.*stats.*|.*metric.*|.*count.*': 600,   # 10分钟
             
-            return {
-                'hits': hits,
-                'misses': self.stats['misses'],
-                'sets': self.stats['sets'],
-                'deletes': self.stats['deletes'],
-                'errors': self.stats['errors'],
-                'total_operations': total_ops,
-                'hit_rate': round(hit_rate, 2),
-                'avg_response_time': round(avg_response_time, 4),
-                'ops_per_second': round(ops_per_second, 2),
-                'uptime_seconds': int(uptime),
-                'hot_keys': dict(top_hot_keys),
-                'unique_keys_count': len(self.hot_keys)
-            }
-    
-    def health_check(self) -> Dict[str, Any]:
-        """健康检查"""
-        health_info = {
-            'redis_connected': False,
-            'mysql_available': False,
-            'stats_worker_running': self._stats_running,
-            'instance_name': self.instance_name,
-            'timestamp': datetime.now().isoformat()
+            # 缓存相关 - 变化频率高，TTL较短
+            r'.*cache.*|.*temp.*|.*tmp.*': 180,       # 3分钟
+            
+            # 列表相关 - 变化频率中等，TTL中等
+            r'.*list.*|.*index.*|.*catalog.*': 450,   # 7.5分钟
         }
         
-        # 检查Redis连接
-        try:
-            self.redis_client.ping()
-            health_info['redis_connected'] = True
-        except Exception as e:
-            health_info['redis_error'] = str(e)
+        # 合并用户自定义模式（优先级更高）
+        namespace_patterns.update(self.config.custom_namespace_patterns)
         
-        # 检查MySQL连接
-        if self.mysql_pool:
-            try:
-                connection = self.mysql_pool.connection()
-                connection.close()
-                health_info['mysql_available'] = True
-            except Exception as e:
-                health_info['mysql_error'] = str(e)
+        # 2. 基于键名模式的智能匹配
+        key_patterns = {
+            # ID相关 - 相对稳定
+            r'.*_id$|^id_.*': 1.2,  # TTL倍数
+            
+            # 详情相关 - 相对稳定
+            r'.*detail.*|.*info.*': 1.1,
+            
+            # 列表相关 - 变化较频繁
+            r'.*list.*|.*items.*': 0.8,
+            
+            # 计数相关 - 变化频繁
+            r'.*count.*|.*num.*|.*total.*': 0.6,
+            
+            # 状态相关 - 变化很频繁
+            r'.*status.*|.*state.*': 0.5,
+        }
         
-        return health_info
-    
-    def _start_stats_worker(self):
-        """启动统计工作线程"""
-        if not self._stats_running and self.mysql_pool:
-            self._stats_running = True
-            self._stats_thread = threading.Thread(
-                target=self._stats_worker, 
-                daemon=True,
-                name=f"stats_worker_{self.instance_name}"
-            )
-            self._stats_thread.start()
-            self.logger.info("统计工作线程已启动", {
-                'instance_name': self.instance_name,
-                'delay_first_run': True
+        # 合并用户自定义键模式
+        key_patterns.update(self.config.custom_key_patterns)
+        
+        # 3. 基于数据大小的调整
+        size_factor = 1.0
+        if data_size > 0:
+            if data_size > 1024 * 1024:  # > 1MB，延长TTL减少重建开销
+                size_factor = 1.5
+            elif data_size > 100 * 1024:  # > 100KB
+                size_factor = 1.2
+            elif data_size < 1024:  # < 1KB，缩短TTL减少内存占用
+                size_factor = 0.8
+        
+        # 4. 计算基础TTL
+        base_ttl = self.config.default_ttl
+        
+        # 匹配命名空间模式
+        for pattern, ttl in namespace_patterns.items():
+            if re.match(pattern, namespace.lower()):
+                base_ttl = ttl
+                break
+        
+        # 5. 应用键名模式调整
+        key_factor = 1.0
+        for pattern, factor in key_patterns.items():
+            if re.match(pattern, key.lower()):
+                key_factor = factor
+                break
+        
+        # 6. 计算最终TTL
+        final_ttl = int(base_ttl * key_factor * size_factor)
+        
+        # 7. TTL边界限制（使用配置值）
+        final_ttl = max(self.config.ttl_min, min(self.config.ttl_max, final_ttl))
+        
+        # 8. 记录智能TTL决策（使用配置开关）
+        if self.config.debug_ttl:
+            logger.debug("智能TTL计算", {
+                'namespace': namespace,
+                'key': key[:50] + "..." if len(key) > 50 else key,
+                'data_size': data_size,
+                'base_ttl': base_ttl,
+                'key_factor': key_factor,
+                'size_factor': size_factor,
+                'final_ttl': final_ttl
             })
+        
+        return final_ttl
     
-    def _stats_worker(self):
-        """后台统计工作线程"""
-        cleanup_counter = 0
+    def get_stats(self) -> Dict[str, Any]:
+        """获取统计信息"""
+        # 确保统计系统已初始化
+        if self.stats_collector:
+            return self.stats_collector.get_stats()
         
-        # 延迟启动：等待一个完整的统计间隔
-        self.logger.info("统计线程启动，等待首个统计间隔", {
+        logger.debug("统计系统未初始化，返回空统计信息", {
             'instance_name': self.instance_name,
-            'interval': self.config.stats_interval,
-            'delay_reason': '避免初始化时的阻塞操作'
+            'process_id': os.getpid()
         })
-        
-        # 使用可中断的等待
-        if not self._interruptible_sleep(self.config.stats_interval):
-            return  # 如果被中断则退出
-        
-        while self._stats_running:
-            try:
-                # 收集统计数据
-                stats_data = self.get_stats()
-                
-                # 提交到MySQL（带状态检查）
-                self._submit_stats_to_mysql(stats_data)
-                
-                # 清理过期的热点键统计
-                self._cleanup_hot_keys()
-                
-                # 定期清理过期数据
-                cleanup_counter += 1
-                if cleanup_counter >= 24:  # 24 * 1800秒 = 12小时
-                    self._cleanup_expired_mysql_data()
-                    cleanup_counter = 0
-                
-            except Exception as e:
-                self.logger.error(f"统计工作线程异常: {e}")
-            
-            # 可中断的等待下一个统计间隔
-            if not self._interruptible_sleep(self.config.stats_interval):
-                break
+        return {
+            'enabled': False,
+            'message': '统计系统未初始化',
+            'process_id': os.getpid()
+        }
     
-    def _interruptible_sleep(self, duration: float) -> bool:
-        """可中断的睡眠"""
-        sleep_interval = 1.0  # 每秒检查一次
-        elapsed = 0.0
-        
-        while elapsed < duration and self._stats_running:
-            time.sleep(min(sleep_interval, duration - elapsed))
-            elapsed += sleep_interval
+    def health_check(self) -> Dict[str, Any]:
+        """健康检查"""
+        try:
+            # Redis连接检查
+            redis_latency = time.time()
+            self.redis_client.ping()
+            redis_latency = (time.time() - redis_latency) * 1000
             
-        return self._stats_running
-    
-    def _submit_stats_to_mysql(self, stats_data: Dict[str, Any]):
-        """提交统计数据到MySQL"""
-        if not self.mysql_pool:
-            self.logger.debug("MySQL连接池不可用，跳过统计数据提交")
-            return
+            # 获取Redis信息
+            redis_info = self.redis_client.info()
             
-        # 使用状态检查而不是属性检查
-        if not self.is_mysql_ready:
-            self.logger.debug("MySQL尚未就绪，跳过统计数据提交", {
-                'state': self._state.value,
-                'instance_name': self.instance_name
-            })
-            return
+            return {
+                'status': 'healthy',
+                'redis_connected': True,
+                'redis_latency_ms': round(redis_latency, 2),
+                'mysql_enabled': self.mysql_pool is not None,
+                'mysql_ready': self.is_mysql_ready,
+                'system_state': self._state.value,
+                'uptime_seconds': time.time() - (self.stats_collector.stats['start_time'] if self.stats_collector else time.time()),
+                'redis_memory_used': redis_info.get('used_memory', 0),
+                'redis_connected_clients': redis_info.get('connected_clients', 0),
+                'process_id': os.getpid()
+            }
             
-        logger.info("统计数据", {'stats_data': stats_data})
-
-        try:
-            # 使用上下文管理器确保连接正确关闭
-            connection = self.mysql_pool.connection()
-            try:
-                with connection.cursor() as cursor:
-                    cursor.execute(f"USE `{self.config.db_name}`")
-                    
-                    # 准备数据
-                    now = datetime.now()
-                    date_str = now.strftime("%Y-%m-%d")
-                    time_period = now.strftime("%Y%m%d_%H%M")
-                    
-                    insert_sql = f"""
-                    INSERT INTO `{self.config.table_name}` (
-                        `日期`, `统计时间`, `时间段`, `缓存命中数`, `缓存未命中数`, `缓存设置数`,
-                        `缓存删除数`, `缓存错误数`, `命中率`, `总操作数`, `平均响应时间`,
-                        `每秒操作数`, `唯一键数量`, `系统运行时间`, `热点键统计`,
-                        `服务器主机`, `实例名称`
-                    ) VALUES (
-                        %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
-                    )
-                    """
-                    
-                    cursor.execute(insert_sql, (
-                        date_str,
-                        now,
-                        time_period,
-                        stats_data['hits'],
-                        stats_data['misses'],
-                        stats_data['sets'],
-                        stats_data['deletes'],
-                        stats_data['errors'],
-                        stats_data['hit_rate'],
-                        stats_data['total_operations'],
-                        stats_data['avg_response_time'],
-                        stats_data['ops_per_second'],
-                        stats_data['unique_keys_count'],
-                        stats_data['uptime_seconds'],
-                        json.dumps(stats_data['hot_keys'], ensure_ascii=False, cls=MySQLDataEncoder),
-                        socket.gethostname(),
-                        self.instance_name
-                    ))
-                    
-                    connection.commit()
-                    
-                    self.logger.info("统计数据已提交到MySQL", {
-                        'time_period': time_period,
-                        'total_operations': stats_data['total_operations'],
-                        'hit_rate': stats_data['hit_rate'],
-                        'instance_name': self.instance_name
-                    })
-                    
-            finally:
-                connection.close()
-                
         except Exception as e:
-            self.logger.error(f"提交统计数据到MySQL失败: {e}", {
-                'instance_name': self.instance_name,
-                'error_type': type(e).__name__
-            })
-    
-    def _cleanup_hot_keys(self):
-        """清理热点键统计 """
-        with self.hot_keys_lock:
-            current_count = len(self.hot_keys)
-            
-            # 如果热点键数量超过最大限制，进行清理
-            if current_count > self.config.max_hot_keys:
-                # 保留访问次数最高的键
-                sorted_keys = sorted(self.hot_keys.items(), key=lambda x: x[1], reverse=True)
-                # 保留80%的热点键
-                keep_count = int(self.config.max_hot_keys * 0.8)
-                self.hot_keys = dict(sorted_keys[:keep_count])
-                
-                self.logger.info("定期热点键清理", {
-                    '清理前数量': current_count,
-                    '清理后数量': len(self.hot_keys),
-                    '保留比例': '80%'
-                })
+            return {
+                'status': 'unhealthy',
+                'error': str(e),
+                'redis_connected': False,
+                'system_state': self._state.value
+            }
     
-    def _cleanup_expired_mysql_data(self):
-        """清理过期的MySQL统计数据"""
-        if not self.mysql_pool:
+    def _record_operation(self, operation: str, response_time: float = 0, namespace: str = "", key: str = ""):
+        """记录操作统计 """
+        # 如果禁用统计功能，直接返回
+        if not self.config.enable_stats:
             return
+            
+        logger.debug("调用操作记录", {
+            'operation': operation,
+            'response_time_ms': round(response_time, 2),
+            'namespace': namespace,
+            'key': key[:50] + "..." if len(key) > 50 else key,
+            'instance_name': self.instance_name
+        })
         
-        try:
-            connection = self.mysql_pool.connection()
-            try:
-                with connection.cursor() as cursor:
-                    cursor.execute(f"USE `{self.config.db_name}`")
-                    
-                    # 计算过期时间点
-                    from datetime import timedelta
-                    expire_date = datetime.now() - timedelta(days=self.config.stats_retention)
-                    
-                    # 删除过期数据
-                    delete_sql = f"""
-                    DELETE FROM `{self.config.table_name}` 
-                    WHERE `统计时间` < %s
-                    """
-                    
-                    cursor.execute(delete_sql, (expire_date,))
-                    deleted_rows = cursor.rowcount
-                    connection.commit()
-                    
-                    if deleted_rows > 0:
-                        self.logger.info("清理过期MySQL统计数据", {
-                            'deleted_rows': deleted_rows,
-                            'expire_date': expire_date.strftime('%Y-%m-%d %H:%M:%S'),
-                            'retention_days': self.config.stats_retention
-                        })
-                    
-            finally:
-                connection.close()
-                
-        except Exception as e:
-            self.logger.error(f"清理过期MySQL统计数据失败: {e}")
-    
     def shutdown(self):
         """关闭缓存系统"""
-        self.logger.info("正在关闭缓存系统...", {
-            'instance_name': self.instance_name,
-            'state': self._state.value
-        })
+        self._state = CacheSystemState.SHUTDOWN
         
-        # 停止统计线程
-        self._stats_running = False
-        if self._stats_thread and self._stats_thread.is_alive():
-            self.logger.info("等待统计线程结束...")
-            self._stats_thread.join(timeout=10)  # 最多等待10秒
-            
-            if self._stats_thread.is_alive():
-                self.logger.warning("统计线程未能在超时时间内结束")
-        
-        # 关闭线程池
-        if hasattr(self, '_executor'):
-            self.logger.info("关闭线程池...")
-            self._executor.shutdown(wait=True, timeout=5)
-        
-        # 最后一次提交统计数据（如果MySQL可用）
-        if self.is_mysql_ready:
-            try:
-                self.logger.info("提交最终统计数据...")
-                stats_data = self.get_stats()
-                self._submit_stats_to_mysql(stats_data)
-            except Exception as e:
-                self.logger.error(f"关闭时提交统计数据失败: {e}")
+        if self.stats_collector:
+            # The stats_submitter is now a CacheStatsCollector, so we call its reset_stats
+            self.stats_collector.reset_stats()
         
-        self.logger.info("缓存系统已关闭", {
-            'instance_name': self.instance_name
-        })
-    
-    def __enter__(self):
-        """上下文管理器支持"""
-        return self
-    
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """上下文管理器退出时自动关闭"""
-        self.shutdown()
-        return False
+        logger.info("缓存系统已关闭", {'instance_name': self.instance_name})
 
 
 class CacheManager:
-    """缓存管理器 - 单例模式"""
+    """缓存管理器"""
     
     _instance = None
-    _lock = threading.RLock()
+    _lock = threading.Lock()
     
     def __new__(cls):
-        with cls._lock:
-            if cls._instance is None:
-                cls._instance = super().__new__(cls)
-                cls._instance._initialized = False
-            return cls._instance
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
     
     def __init__(self):
-        if self._initialized:
+        if not hasattr(self, '_initialized'):
+            self.cache_instance = None
+            self._initialized = True
+    
+    def initialize(self, redis_client: redis.Redis, mysql_pool=None, instance_name: str = "default", **config):
+        """初始化缓存系统"""
+        if self.cache_instance is not None:
+            logger.warning("缓存系统已初始化，跳过重复初始化", {
+                'existing_instance': self.cache_instance.instance_name,
+                'new_instance': instance_name
+            })
             return
         
-        self.cache_instance = None
-        self.enabled = True
-        self.initialization_error = None
-        self._initialized = True
-        self.logger = logger
-    
-    def initialize(self, redis_client: redis.Redis, mysql_pool=None, instance_name: str = "default",
-                   config: CacheConfig = None, db_name: str = None, table_name: str = None):
-        """初始化缓存系统（非阻塞）"""
-        try:
-            # 立即创建缓存实例，内部会异步初始化MySQL和统计线程
-            self.cache_instance = SmartCacheSystem(
-                redis_client=redis_client,
-                mysql_pool=mysql_pool,
-                instance_name=instance_name,
-                config=config,
-                db_name=db_name,
-                table_name=table_name
-            )
-            self.initialization_error = None
-            self.logger.info("缓存管理器初始化成功（异步模式）", {
-                'instance_name': instance_name,
-                'mysql_enabled': mysql_pool is not None,
-                'db_name': self.cache_instance.config.db_name,
-                'table_name': self.cache_instance.config.table_name,
-                'note': 'MySQL初始化将在后台异步完成'
-            })
-            return self  # 支持链式调用
-            
-        except Exception as e:
-            self.initialization_error = str(e)
-            self.cache_instance = None
-            self.logger.error(f"缓存管理器初始化失败: {e}")
-            return self
+        self.cache_instance = SmartCacheSystem(
+            redis_client=redis_client,
+            mysql_pool=mysql_pool,
+            instance_name=instance_name,
+            **config
+        )
     
     def get_cache(self) -> Optional[SmartCacheSystem]:
         """获取缓存实例"""
-        return self.cache_instance if self.enabled else None
+        return self.cache_instance
     
     def is_available(self) -> bool:
         """检查缓存是否可用"""
-        return self.cache_instance is not None and self.enabled
-    
-    def enable(self):
-        """启用缓存"""
-        self.enabled = True
-        self.logger.info("缓存系统已启用")
-        return self  # 支持链式调用
-    
-    def disable(self):
-        """禁用缓存"""
-        self.enabled = False
-        self.logger.info("缓存系统已禁用")
-        return self  # 支持链式调用
+        return self.cache_instance is not None and self.cache_instance.is_ready
     
     def get_status(self) -> Dict[str, Any]:
         """获取缓存状态"""
+        if self.cache_instance is None:
+            return {
+                'enabled': False,
+                'available': False,
+                'stats_enabled': False,
+                'initialization_error': 'Cache not initialized'
+            }
+        
         return {
-            'enabled': self.enabled,
-            'available': self.cache_instance is not None,
-            'initialization_error': self.initialization_error,
-            'instance_name': getattr(self.cache_instance, 'instance_name', None) if self.cache_instance else None
+            'enabled': True,
+            'available': self.cache_instance.is_ready,
+            'mysql_ready': self.cache_instance.is_mysql_ready,
+            'stats_enabled': self.cache_instance.config.enable_stats,
+            'state': self.cache_instance._state.value,
+            'instance_name': self.cache_instance.instance_name
         }
-    
-    def shutdown(self):
-        """关闭缓存系统"""
-        if self.cache_instance:
-            self.cache_instance.shutdown()
-            self.cache_instance = None
-        self.logger.info("缓存管理器已关闭")
 
 
-# 导出单例实例
+# 全局缓存管理器实例
 cache_manager = CacheManager()