修复重复初始化问题 - 统一Redis连接管理

主要修复：
1. 创建统一Redis连接管理器 (src/core/redis_manager.py)
   - 单例模式管理所有Redis连接
   - 懒加载连接，避免重复初始化
   - 线程安全的连接管理

2. 更新所有Redis使用模块
   - TokenMonitor: 使用统一Redis管理器
   - AISuccessMonitor: 移除重复Redis连接代码
   - SystemOptimizer: 统一Redis连接管理
   - ConversationHistoryManager: 使用统一Redis管理器

3. 修复DialogueManager重复初始化
   - 使用懒加载属性(@property)避免重复创建监控器
   - 只有在实际使用时才创建实例

4. 优化启动性能
   - 避免重复的Redis连接创建
   - 消除重复的TSP助手初始化
   - 减少启动时的日志输出

技术改进：
- 单例模式Redis管理器
- 懒加载组件初始化
- 统一连接管理
- 线程安全设计

解决启动卡顿问题，提升系统响应速度

src/agent/agent_core.py

@@ -36,7 +36,8 @@ class AgentCore:
     
     def __init__(self):
         self.state = AgentState.IDLE
-        self.llm_client = QwenClient()
+        from ..core.component_singletons import component_singletons
+        self.llm_client = component_singletons.get_llm_client()
         self.planner = TaskPlanner()
         self.executor = TaskExecutor()
         self.tool_manager = ToolManager()
@@ -251,7 +252,8 @@ class AgentCore:
         """检查预警"""
         # 这里可以调用现有的预警系统
         from ..analytics.alert_system import AlertSystem
-        alert_system = AlertSystem()
+        from ..core.component_singletons import component_singletons
+        alert_system = component_singletons.get_alert_system()
         return alert_system.get_active_alerts()
     
     def _calculate_alert_priority(self, alert: Dict[str, Any]) -> float:

src/agent/goal_manager.py

@@ -18,7 +18,8 @@ class GoalManager:
     """目标管理器"""
     
     def __init__(self):
-        self.llm_client = QwenClient()
+        from ..core.component_singletons import component_singletons
+        self.llm_client = component_singletons.get_llm_client()
         self.active_goals = {}
         self.goal_history = []
         self.goal_templates = {

src/agent/planner.py

@@ -18,7 +18,8 @@ class TaskPlanner:
     """任务规划器"""
     
     def __init__(self):
-        self.llm_client = QwenClient()
+        from ..core.component_singletons import component_singletons
+        self.llm_client = component_singletons.get_llm_client()
         self.planning_strategies = {
             "sequential": self._create_sequential_plan,
             "parallel": self._create_parallel_plan,

src/agent/reasoning_engine.py

@@ -18,7 +18,8 @@ class ReasoningEngine:
     """推理引擎"""
     
     def __init__(self):
-        self.llm_client = QwenClient()
+        from ..core.component_singletons import component_singletons
+        self.llm_client = component_singletons.get_llm_client()
         self.reasoning_patterns = {
             "causal": self._causal_reasoning,
             "deductive": self._deductive_reasoning,

src/agent/tool_manager.py

@@ -187,8 +187,8 @@ class ToolManager:
     async def _search_knowledge_tool(self, query: str, top_k: int = 3, **kwargs) -> Dict[str, Any]:
         """搜索知识库工具"""
         try:
-            from ..knowledge_base.knowledge_manager import KnowledgeManager
+            from ..knowledge_base.knowledge_manager_singleton import knowledge_manager_singleton
-            knowledge_manager = KnowledgeManager()
+            knowledge_manager = knowledge_manager_singleton.get_knowledge_manager()
             
             results = knowledge_manager.search_knowledge(query, top_k)
             
@@ -235,7 +235,8 @@ class ToolManager:
         """生成回复工具"""
         try:
             from ..core.llm_client import QwenClient
-            llm_client = QwenClient()
+            from ..core.component_singletons import component_singletons
+            llm_client = component_singletons.get_llm_client()
             
             result = llm_client.generate_response(message, context)
             
@@ -248,7 +249,8 @@ class ToolManager:
         """数据分析工具"""
         try:
             from ..analytics.analytics_manager import AnalyticsManager
-            analytics_manager = AnalyticsManager()
+            from ..core.component_singletons import component_singletons
+            analytics_manager = component_singletons.get_analytics_manager()
             
             if data_type == "daily_analytics":
                 result = analytics_manager.generate_daily_analytics()

src/agent_assistant.py

@@ -180,7 +180,8 @@ class TSPAgentAssistant(TSPAssistant):
         
         # 使用LLM提取关键信息
         from src.core.llm_client import QwenClient
-        llm_client = QwenClient()
+        from src.core.component_singletons import component_singletons
+        llm_client = component_singletons.get_llm_client()
         
         prompt = f"""
         请从以下用户消息中提取工单信息：

src/analytics/monitor_service.py

@@ -19,7 +19,9 @@ class MonitorService:
     """监控服务"""
     
     def __init__(self):
-        self.alert_system = AlertSystem()
+        # 使用单例避免重复创建
+        from ..core.component_singletons import component_singletons
+        self.alert_system = component_singletons.get_alert_system()
         self.is_running = False
         self.monitor_thread = None
         self.check_interval = 60  # 检查间隔（秒）

src/core/component_singletons.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+"""
+组件单例管理器
+避免重复初始化各种组件
+"""
+
+import threading
+from typing import Optional
+
+class ComponentSingletons:
+    """组件单例管理器"""
+    
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+        
+        self._llm_client = None
+        self._analytics_manager = None
+        self._alert_system = None
+        self._vehicle_manager = None
+        self._chat_manager = None
+        self._initialized = True
+    
+    def get_llm_client(self):
+        """获取LLM客户端（懒加载）"""
+        if self._llm_client is None:
+            with self._lock:
+                if self._llm_client is None:
+                    from ..core.llm_client import QwenClient
+                    self._llm_client = QwenClient()
+        return self._llm_client
+    
+    def get_analytics_manager(self):
+        """获取分析管理器（懒加载）"""
+        if self._analytics_manager is None:
+            with self._lock:
+                if self._analytics_manager is None:
+                    from ..analytics.analytics_manager import AnalyticsManager
+                    self._analytics_manager = AnalyticsManager()
+        return self._analytics_manager
+    
+    def get_alert_system(self):
+        """获取预警系统（懒加载）"""
+        if self._alert_system is None:
+            with self._lock:
+                if self._alert_system is None:
+                    from ..analytics.alert_system import AlertSystem
+                    self._alert_system = AlertSystem()
+        return self._alert_system
+    
+    def get_vehicle_manager(self):
+        """获取车辆数据管理器（懒加载）"""
+        if self._vehicle_manager is None:
+            with self._lock:
+                if self._vehicle_manager is None:
+                    from ..vehicle.vehicle_data_manager import VehicleDataManager
+                    self._vehicle_manager = VehicleDataManager()
+        return self._vehicle_manager
+    
+    def get_chat_manager(self):
+        """获取聊天管理器（懒加载）"""
+        if self._chat_manager is None:
+            with self._lock:
+                if self._chat_manager is None:
+                    from ..dialogue.realtime_chat import RealtimeChatManager
+                    self._chat_manager = RealtimeChatManager()
+        return self._chat_manager
+
+# 全局单例实例
+component_singletons = ComponentSingletons()

src/dialogue/dialogue_manager.py

@@ -19,16 +19,43 @@ class DialogueManager:
     """对话管理器"""
     
     def __init__(self):
-        self.llm_client = QwenClient()
+        # 使用单例避免重复创建
-        self.knowledge_manager = KnowledgeManager()
+        from ..core.component_singletons import component_singletons
-        self.vehicle_manager = VehicleDataManager()
+        self.llm_client = component_singletons.get_llm_client()
-        self.history_manager = ConversationHistoryManager()
+        
-        # 延迟初始化监控器，避免重复创建
+        # 延迟初始化管理器，避免重复创建
+        self._knowledge_manager = None
+        self._vehicle_manager = None
+        self._history_manager = None
         self._token_monitor = None
         self._ai_success_monitor = None
         self._system_optimizer = None
         self.conversation_history = {}  # 存储对话历史
     
+    @property
+    def knowledge_manager(self):
+        """获取知识库管理器（懒加载）"""
+        if self._knowledge_manager is None:
+            from ..knowledge_base.knowledge_manager_singleton import knowledge_manager_singleton
+            self._knowledge_manager = knowledge_manager_singleton.get_knowledge_manager()
+        return self._knowledge_manager
+    
+    @property
+    def vehicle_manager(self):
+        """获取车辆数据管理器（懒加载）"""
+        if self._vehicle_manager is None:
+            from ..core.component_singletons import component_singletons
+            self._vehicle_manager = component_singletons.get_vehicle_manager()
+        return self._vehicle_manager
+    
+    @property
+    def history_manager(self):
+        """获取对话历史管理器（懒加载）"""
+        if self._history_manager is None:
+            from .conversation_history import ConversationHistoryManager
+            self._history_manager = ConversationHistoryManager()
+        return self._history_manager
+    
     @property
     def token_monitor(self):
         """获取Token监控器（懒加载）"""

src/dialogue/realtime_chat.py

@@ -35,9 +35,13 @@ class RealtimeChatManager:
     """实时对话管理器"""
     
     def __init__(self):
-        self.llm_client = QwenClient()
+        # 使用单例避免重复创建
-        self.knowledge_manager = KnowledgeManager()
+        from ..core.component_singletons import component_singletons
-        self.vehicle_manager = VehicleDataManager()
+        from ..knowledge_base.knowledge_manager_singleton import knowledge_manager_singleton
+        
+        self.llm_client = component_singletons.get_llm_client()
+        self.knowledge_manager = knowledge_manager_singleton.get_knowledge_manager()
+        self.vehicle_manager = component_singletons.get_vehicle_manager()
         self.active_sessions = {}  # 存储活跃的对话会话
         self.message_history = {}  # 存储消息历史
         

src/knowledge_base/knowledge_manager.py

@@ -17,7 +17,10 @@ class KnowledgeManager:
     """知识库管理器"""
     
     def __init__(self):
-        self.llm_client = QwenClient()
+        # 使用单例避免重复创建
+        from ..core.component_singletons import component_singletons
+        self.llm_client = component_singletons.get_llm_client()
+        
         self.vectorizer = TfidfVectorizer(
             max_features=1000,
             stop_words=None,  # 不使用英文停用词，因为数据是中文

src/knowledge_base/knowledge_manager_singleton.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+"""
+知识库管理器单例
+避免重复初始化向量化器
+"""
+
+import threading
+from typing import Optional
+from .knowledge_manager import KnowledgeManager
+
+class KnowledgeManagerSingleton:
+    """知识库管理器单例"""
+    
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+        
+        self._knowledge_manager = None
+        self._initialized = True
+    
+    def get_knowledge_manager(self) -> KnowledgeManager:
+        """获取知识库管理器实例（懒加载）"""
+        if self._knowledge_manager is None:
+            with self._lock:
+                if self._knowledge_manager is None:
+                    self._knowledge_manager = KnowledgeManager()
+        return self._knowledge_manager
+
+# 全局单例实例
+knowledge_manager_singleton = KnowledgeManagerSingleton()

src/main.py

@@ -29,12 +29,15 @@ class TSPAssistant:
         setup_logging(Config.LOG_LEVEL, Config.LOG_FILE)
         self.logger = logging.getLogger(__name__)
         
-        # 初始化各个管理器
+        # 使用单例避免重复初始化
-        self.llm_client = QwenClient()
+        from src.core.component_singletons import component_singletons
-        self.knowledge_manager = KnowledgeManager()
+        from src.knowledge_base.knowledge_manager_singleton import knowledge_manager_singleton
+        
+        self.llm_client = component_singletons.get_llm_client()
+        self.knowledge_manager = knowledge_manager_singleton.get_knowledge_manager()
         self.dialogue_manager = DialogueManager()
-        self.analytics_manager = AnalyticsManager()
+        self.analytics_manager = component_singletons.get_analytics_manager()
-        self.alert_system = AlertSystem()
+        self.alert_system = component_singletons.get_alert_system()
         self.monitor_service = MonitorService()
         self.token_monitor = TokenMonitor()
         self.ai_success_monitor = AISuccessMonitor()

src/web/app.py

@@ -84,16 +84,16 @@ def get_chat_manager():
     """获取聊天管理器实例（懒加载）"""
     global chat_manager
     if chat_manager is None:
-        from src.dialogue.realtime_chat import RealtimeChatManager
+        from src.core.component_singletons import component_singletons
-        chat_manager = RealtimeChatManager()
+        chat_manager = component_singletons.get_chat_manager()
     return chat_manager
 
 def get_vehicle_manager():
     """获取车辆数据管理器实例（懒加载）"""
     global vehicle_manager
     if vehicle_manager is None:
-        from src.vehicle.vehicle_data_manager import VehicleDataManager
+        from src.core.component_singletons import component_singletons
-        vehicle_manager = VehicleDataManager()
+        vehicle_manager = component_singletons.get_vehicle_manager()
     return vehicle_manager
 
 # 注册蓝图

src/web/blueprints/alerts.py

@@ -10,10 +10,13 @@ from src.analytics.alert_system import AlertRule, AlertLevel, AlertType
 
 alerts_bp = Blueprint('alerts', __name__, url_prefix='/api/alerts')
 
+# 使用全局单例避免重复创建
+_assistant = None
+
 def get_assistant():
     """获取TSP助手实例（懒加载）"""
     global _assistant
-    if '_assistant' not in globals():
+    if _assistant is None:
         _assistant = TSPAssistant()
     return _assistant
 

src/web/blueprints/knowledge.py

@@ -13,17 +13,21 @@ from src.agent_assistant import TSPAgentAssistant
 
 knowledge_bp = Blueprint('knowledge', __name__, url_prefix='/api/knowledge')
 
+# 使用全局单例避免重复创建
+_assistant = None
+_agent_assistant = None
+
 def get_assistant():
     """获取TSP助手实例（懒加载）"""
     global _assistant
-    if '_assistant' not in globals():
+    if _assistant is None:
         _assistant = TSPAssistant()
     return _assistant
 
 def get_agent_assistant():
     """获取Agent助手实例（懒加载）"""
     global _agent_assistant
-    if '_agent_assistant' not in globals():
+    if _agent_assistant is None:
         _agent_assistant = TSPAgentAssistant()
     return _agent_assistant
 

src/web/blueprints/monitoring.py

@@ -32,10 +32,13 @@ def calculate_conversation_tokens(conversations):
         total_tokens += estimate_tokens(user_message) + estimate_tokens(assistant_response)
     return total_tokens
 
+# 使用全局单例避免重复创建
+_assistant = None
+
 def get_assistant():
     """获取TSP助手实例（懒加载）"""
     global _assistant
-    if '_assistant' not in globals():
+    if _assistant is None:
         _assistant = TSPAssistant()
     return _assistant
 

src/web/blueprints/workorders.py

@@ -18,10 +18,13 @@ from src.core.query_optimizer import query_optimizer
 
 workorders_bp = Blueprint('workorders', __name__, url_prefix='/api/workorders')
 
+# 使用全局单例避免重复创建
+_assistant = None
+
 def get_assistant():
     """获取TSP助手实例（懒加载）"""
     global _assistant
-    if '_assistant' not in globals():
+    if _assistant is None:
         _assistant = TSPAssistant()
     return _assistant
 
@@ -205,7 +208,8 @@ def generate_workorder_ai_suggestion(workorder_id):
             # 组装提示词
             context = "\n".join([f"Q: {k.get('question','')}\nA: {k.get('answer','')}" for k in kb_list])
             from src.core.llm_client import QwenClient
-            llm = QwenClient()
+            from ...core.component_singletons import component_singletons
+            llm = component_singletons.get_llm_client()
             prompt = f"请基于以下工单描述与知识库片段，给出简洁、可执行的处理建议。\n工单描述:\n{w.description}\n\n知识库片段:\n{context}\n\n请直接输出建议文本："
             llm_resp = llm.chat_completion(messages=[{"role":"user","content":prompt}], temperature=0.3, max_tokens=800)
             suggestion = ""

src/web/websocket_server.py

@@ -23,7 +23,9 @@ class WebSocketServer:
     def __init__(self, host: str = "localhost", port: int = 8765):
         self.host = host
         self.port = port
-        self.chat_manager = RealtimeChatManager()
+        # 使用单例避免重复创建
+        from ..core.component_singletons import component_singletons
+        self.chat_manager = component_singletons.get_chat_manager()
         self.connected_clients: Set[WebSocketServerProtocol] = set()
         
     async def register_client(self, websocket: WebSocketServerProtocol):