sycommon-python-lib 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

sycommon/synacos/nacos_service.py

@@ -9,7 +9,6 @@ import os
 import yaml
 import time
 import atexit
-import traceback
 import random
 from concurrent.futures import ThreadPoolExecutor
 
@@ -26,10 +25,21 @@ class NacosService(metaclass=SingletonMeta):
             self.host = config['Host']
             self.port = config['Port']
             self.version = os.getenv('VERSION')
+            self.enable_register_nacos = os.getenv(
+                'REGISTER-NACOS', 'true').lower() == 'true'
             self.registered = False
             self._client_initialized = False  # 客户端初始化状态
             self._shutdown_event = threading.Event()
-            self._executor = ThreadPoolExecutor(max_workers=5)
+
+            # 添加可重入锁用于状态同步
+            self._state_lock = threading.RLock()
+
+            # 优化线程池配置，增加工作线程数量
+            self._executor = ThreadPoolExecutor(max_workers=1)  # 主线程池
+            self._heartbeat_executor = ThreadPoolExecutor(
+                max_workers=1)  # 增加心跳线程
+            self._monitor_executor = ThreadPoolExecutor(
+                max_workers=1)  # 增加监控线程
 
             # 配置参数
             self.max_retries = self.nacos_config.get('maxRetries', 5)
@@ -49,18 +59,20 @@ class NacosService(metaclass=SingletonMeta):
 
             # 注册验证配置
             self.registration_verify_count = self.nacos_config.get(
-                'registrationVerifyCount', 3)  # 验证次数
+                'registrationVerifyCount', 1)  # 验证次数
             self.registration_verify_interval = self.nacos_config.get(
                 'registrationVerifyInterval', 1)  # 验证间隔
 
             self.real_ip = self.get_service_ip(self.host)
             self._long_term_retry_count = 0  # 长期重试计数器
 
-            # 初始化客户端（仅在首次调用时执行）
-            self._initialize_client()
-
-            # 启动时清理残留实例
-            self._cleanup_stale_instance()
+            if self.enable_register_nacos:
+                # 初始化客户端（仅在首次调用时执行）
+                self._initialize_client()
+                # 启动时清理残留实例
+                self._cleanup_stale_instance()
+            else:
+                SYLogger.info("nacos:本地开发模式，不初始化Nacos客户端")
 
             self.share_configs = self.read_configs()
 
@@ -72,14 +84,21 @@ class NacosService(metaclass=SingletonMeta):
             self._last_heartbeat_time = 0
             self._heartbeat_fail_count = 0
             self._heartbeat_thread = None
+            self.max_heartbeat_timeout = self.nacos_config.get(
+                'maxHeartbeatTimeout', 30)  # 最大无心跳时间(秒)
+            self._last_successful_heartbeat = time.time()  # 上次成功心跳时间戳
 
             # 启动配置监视线程
             self._watch_thread = threading.Thread(
                 target=self._watch_configs, daemon=True)
             self._watch_thread.start()
 
-            # 启动心跳线程（在初始化完成后立即启动）
-            self.start_heartbeat()
+            # 仅在需要注册时启动心跳和监控线程
+            if self.enable_register_nacos:
+                # 启动心跳线程
+                self.start_heartbeat()
+            else:
+                SYLogger.info("nacos:本地开发模式，不启动心跳和监控线程")
 
     def _initialize_client(self):
         """初始化Nacos客户端（仅首次调用时执行）"""
@@ -98,8 +117,8 @@ class NacosService(metaclass=SingletonMeta):
                 self._client_initialized = True
                 return True
             except Exception as e:
-                delay = min(self.retry_delay * (self.retry_backoff ** attempt),
-                            self.max_retry_delay)
+                delay = min(self.retry_delay * (self.retry_backoff **
+                            attempt), self.max_retry_delay)
                 SYLogger.error(
                     f"nacos:客户端初始化失败 (尝试 {attempt+1}/{self.max_retries}): {e}")
                 time.sleep(delay)
@@ -119,15 +138,14 @@ class NacosService(metaclass=SingletonMeta):
                 port=int(self.port),
                 cluster_name="DEFAULT"
             )
-            SYLogger.warning(
-                f"nacos:清理残留实例: {self.real_ip}:{self.port}")
+            SYLogger.warning(f"nacos:清理残留实例: {self.real_ip}:{self.port}")
         except Exception as e:
             SYLogger.error(f"nacos:清理残留实例异常: {e}")
 
     def ensure_client_connected(self, retry_once=False):
         """确保Nacos客户端已连接，返回连接状态"""
         # 使用线程锁保护客户端初始化状态
-        with threading.Lock():
+        with self._state_lock:
             if self._client_initialized:
                 return True
 
@@ -163,8 +181,8 @@ class NacosService(metaclass=SingletonMeta):
 
                 except Exception as e:
                     attempt += 1
-                    delay = min(self.retry_delay * (self.retry_backoff ** (attempt - 1)),
-                                self.max_retry_delay)
+                    delay = min(self.retry_delay * (self.retry_backoff **
+                                (attempt - 1)), self.max_retry_delay)
 
                     SYLogger.error(
                         f"nacos:客户端初始化失败 (尝试 {attempt}/{max_attempts}): {e}")
@@ -175,12 +193,15 @@ class NacosService(metaclass=SingletonMeta):
 
     def _verify_client_connection(self):
         """验证客户端是否真正连接成功"""
+        # 本地开发模式下直接返回True，不进行实际验证
+        if not self.enable_register_nacos:
+            return True
+
         try:
             # 使用当前服务的命名实例查询来验证连接
             namespace_id = self.nacos_config['namespaceId']
             self.nacos_client.list_naming_instance(
                 service_name=self.service_name,
-                cluster_name="DEFAULT",
                 namespace_id=namespace_id,
                 group_name="DEFAULT_GROUP",
                 healthy_only=True
@@ -192,24 +213,39 @@ class NacosService(metaclass=SingletonMeta):
 
     def check_service_registered(self):
         """检查服务是否已注册（基于实例列表）"""
+        # 本地开发模式下直接返回True，模拟已注册状态
+        if not self.enable_register_nacos:
+            return True
+
         if not self.ensure_client_connected():
             return False
 
         try:
             namespace_id = self.nacos_config['namespaceId']
             instances = self.nacos_client.list_naming_instance(
-                self.service_name, "DEFAULT", namespace_id, "DEFAULT_GROUP", True)
+                service_name=self.service_name,
+                namespace_id=namespace_id,
+                group_name="DEFAULT_GROUP",
+                healthy_only=True,
+            )
 
             # 检查是否存在包含当前IP和端口的实例
+            found = False
             for instance in instances.get('hosts', []):
                 if (instance.get('ip') == self.real_ip and
                         instance.get('port') == int(self.port)):
-                    SYLogger.info(
-                        f"nacos:找到已注册实例: {self.real_ip}:{self.port}")
-                    return True
+                    SYLogger.info(f"nacos:找到已注册实例: {self.real_ip}:{self.port}")
+                    found = True
+                    break
 
-            SYLogger.warning(f"nacos:未找到注册实例: {self.real_ip}:{self.port}")
-            return False
+            if not found:
+                SYLogger.warning(f"nacos:未找到注册实例: {self.real_ip}:{self.port}")
+
+            # 带锁更新注册状态
+            with self._state_lock:
+                self.registered = found
+
+            return found
         except Exception as e:
             SYLogger.error(f"nacos:检查服务注册状态失败: {e}")
             return False
@@ -243,10 +279,16 @@ class NacosService(metaclass=SingletonMeta):
         retry_count = 0
         last_error = None
 
-        # 重置注册状态，确保重新检查
-        self.registered = False
+        # 带锁重置注册状态
+        with self._state_lock:
+            self.registered = False
+
+        while (not self.registered) and (self.max_long_term_retries < 0 or retry_count < self.max_long_term_retries):
+            # 增加状态检查点，防止重复注册
+            with self._state_lock:
+                if self.registered:
+                    return True
 
-        while not self.registered and (self.max_long_term_retries < 0 or retry_count < self.max_long_term_retries):
             try:
                 # 尝试注册服务
                 register_success = self.register(force=True)
@@ -261,34 +303,46 @@ class NacosService(metaclass=SingletonMeta):
 
                 # 多次验证服务是否真正注册成功
                 registered = self.verify_registration()
-                self.registered = registered  # <-- 确保设置注册状态
 
-                if self.registered:
-                    # 注册成功后，更新客户端状态
-                    self._client_initialized = True
+                # 带锁更新注册状态
+                with self._state_lock:
+                    self.registered = registered
 
-                    # 注册成功后，通知心跳线程立即发送心跳
-                    self._shutdown_event.set()
-                    self._shutdown_event.clear()
+                # 再次检查状态，防止其他线程修改
+                with self._state_lock:
+                    if self.registered:
+                        # 注册成功后，更新客户端状态
+                        self._client_initialized = True
 
-                    # 注册成功后，更新监控线程的状态
-                    self._long_term_retry_count = 0
+                        # 注册成功后，通知心跳线程立即发送心跳
+                        self._shutdown_event.set()
+                        self._shutdown_event.clear()
 
-                    SYLogger.info(f"nacos:服务注册成功并通过验证: {self.service_name}")
-                    return True
-                else:
-                    raise RuntimeError("nacos:服务注册验证失败")
+                        # 注册成功后，更新监控线程的状态
+                        self._long_term_retry_count = 0
+
+                        SYLogger.info(
+                            f"nacos:服务注册成功并通过验证: {self.service_name}")
+                        return True
+                    else:
+                        raise RuntimeError("nacos:服务注册验证失败")
 
             except Exception as e:
                 last_error = str(e)
                 retry_count += 1
-                delay = min(self.register_retry_interval * (self.retry_backoff ** (retry_count - 1)),
-                            self.max_retry_delay)
+                delay = min(self.register_retry_interval *
+                            (self.retry_backoff ** (retry_count - 1)), self.max_retry_delay)
 
                 SYLogger.warning(
                     f"nacos:服务注册尝试 {retry_count} 失败: {last_error}，{delay}秒后重试")
                 time.sleep(delay)
 
+        # 最终检查，防止在最后一次重试后其他线程成功注册
+        with self._state_lock:
+            if self.registered:
+                return True
+
+        # 确实注册失败
         if last_error:
             SYLogger.error(f"nacos:服务注册失败，最终错误: {last_error}")
         else:
@@ -298,8 +352,8 @@ class NacosService(metaclass=SingletonMeta):
 
     def register(self, force=False):
         """注册服务到Nacos"""
-        # 使用线程锁保护注册状态
-        with threading.Lock():
+        # 使用状态锁保护注册状态
+        with self._state_lock:
             if self.registered and not force and self.check_service_registered():
                 return True
 
@@ -352,23 +406,47 @@ class NacosService(metaclass=SingletonMeta):
         """创建并初始化Nacos管理器"""
         instance = NacosService(config)
 
-        # 使用增强的注册重试逻辑
-        if not instance.register_with_retry():
-            # 在抛出异常前，尝试注销服务以清理状态
-            try:
-                instance.deregister_service()
-            except Exception as e:
-                SYLogger.error(f"nacos:服务注册失败后，注销服务时发生错误: {e}")
+        # 仅在需要注册时执行注册逻辑
+        if instance.enable_register_nacos:
+            # 使用带超时的等待机制，而不是单次尝试
+            timeout = 60  # 60秒超时
+            start_time = time.time()
+
+            # 启动注册线程，不阻塞主线程
+            instance._executor.submit(instance.register_with_retry)
+
+            # 等待注册完成或超时
+            while True:
+                # 带锁检查状态
+                with instance._state_lock:
+                    if instance.registered:
+                        break
 
-            raise RuntimeError("nacos:服务注册失败，应用启动终止")
+                if time.time() - start_time >= timeout:
+                    # 超时处理
+                    break
 
-        # 服务注册成功后再注册信号处理
-        signal.signal(signal.SIGTERM, instance.handle_signal)
-        signal.signal(signal.SIGINT, instance.handle_signal)
+                time.sleep(1)
 
-        # 启动连接监控线程
-        threading.Thread(target=instance.monitor_connection,
-                         daemon=True).start()
+            # 最终状态检查
+            with instance._state_lock:
+                if not instance.registered:
+                    # 清理并抛出异常
+                    try:
+                        instance.deregister_service()
+                    except Exception as e:
+                        SYLogger.error(f"nacos:服务注册失败后，注销服务时发生错误: {e}")
+                    raise RuntimeError("nacos:服务注册失败，应用启动终止")
+
+            # 服务注册成功后再注册信号处理
+            signal.signal(signal.SIGTERM, instance.handle_signal)
+            signal.signal(signal.SIGINT, instance.handle_signal)
+
+            # 启动连接监控线程
+            threading.Thread(target=instance.monitor_connection,
+                             daemon=True).start()
+        else:
+            SYLogger.info("nacos:本地开发模式，跳过服务注册流程")
 
         return instance
 
@@ -382,131 +460,94 @@ class NacosService(metaclass=SingletonMeta):
             name="NacosHeartbeatThread",
             daemon=True
         )
+        # 设置线程为守护线程并尝试提高优先级
+        self._heartbeat_thread.daemon = True
         self._heartbeat_thread.start()
-        SYLogger.info("nacos:心跳线程已启动")
 
-    def _send_heartbeat_loop(self):
-        """心跳发送循环 - 独立线程，不依赖外部锁"""
-        SYLogger.info("nacos:心跳线程开始运行")
-        consecutive_failures = 0  # 连续失败次数计数器
-        last_successful_heartbeat = time.time()  # 上次成功心跳时间
-        thread_start_time = time.time()  # 线程启动时间
-        heartbeat_counter = 0  # 心跳计数器
+        try:
+            # 尝试提高线程优先级
+            if hasattr(os, 'sched_setscheduler'):
+                os.sched_setscheduler(
+                    self._heartbeat_thread.ident, os.SCHED_FIFO, os.sched_param(99))
+            elif hasattr(os, 'nice'):
+                os.nice(-10)  # 在Unix系统上尝试提高优先级
+            SYLogger.info("nacos:心跳线程已启动并尝试提高优先级")
+        except Exception as e:
+            SYLogger.warning(f"nacos:无法提高心跳线程优先级: {e}")
 
-        # 初始化为当前时间，以便尽快发送第一次心跳
-        next_heartbeat_time = time.time()
+    def _send_heartbeat_loop(self):
+        """优化后的心跳发送循环，确保严格按间隔执行"""
+        SYLogger.info("nacos:优化版心跳线程开始运行")
+        last_heartbeat_time = time.time()  # 初始时间戳
 
         while not self._shutdown_event.is_set():
+            current_time = time.time()
+            # 计算距离下次心跳的时间（确保严格按间隔执行）
+            sleep_time = max(0, self.heartbeat_interval -
+                             (current_time - last_heartbeat_time))
+
+            if sleep_time > 0:
+                self._shutdown_event.wait(sleep_time)  # 精准等待
+
+            # 执行心跳逻辑
             try:
-                current_time = time.time()
-                SYLogger.info(
-                    f"nacos:心跳线程检查状态，registered={self.registered}, 上次成功心跳: {last_successful_heartbeat}, 运行时间: {current_time-thread_start_time:.2f}s, 心跳计数: {heartbeat_counter}")
-
-                # 检查是否到了发送心跳的时间
-                if current_time >= next_heartbeat_time:
-                    # 复制注册状态，减少锁的持有时间
-                    is_registered = self.registered
-
-                    if is_registered:
-                        # 双重检查，确保服务确实注册
-                        if not self.check_service_registered():
-                            SYLogger.warning(
-                                "nacos:服务状态显示已注册，但Nacos中未找到实例")
-                            self.registered = False
-                            continue
-
-                        SYLogger.info("nacos:准备发送心跳...")
-                        success = self.send_heartbeat()
-                        if success:
-                            heartbeat_counter += 1
-                            consecutive_failures = 0
-                            last_successful_heartbeat = current_time
-                            # 更新下一次计划发送时间
-                            next_heartbeat_time = current_time + self.heartbeat_interval
-                            SYLogger.info(
-                                f"nacos:心跳发送成功({heartbeat_counter})，下次发送时间: {next_heartbeat_time}")
-                        else:
-                            consecutive_failures += 1
-                            # 失败时减少下次发送间隔，加快恢复
-                            next_heartbeat_time = current_time + min(
-                                self.heartbeat_interval,
-                                self.long_term_retry_delay *
-                                (self.retry_backoff **
-                                 (consecutive_failures - 1))
-                            )
-                            SYLogger.warning(
-                                f"nacos:心跳发送失败，将减少下次发送间隔为 {next_heartbeat_time - current_time:.2f} 秒")
+                # 带锁检查注册状态
+                with self._state_lock:
+                    registered_status = self.registered
+
+                if registered_status and self.check_service_registered():
+                    success = self.send_heartbeat()
+                    if success:
+                        self._last_successful_heartbeat = time.time()
+                        SYLogger.info(
+                            f"nacos:心跳发送成功，时间: {self._last_successful_heartbeat:.3f}")
                     else:
-                        SYLogger.warning("nacos:服务未注册，跳过心跳发送")
-                        # 服务未注册时，尝试重新注册
-                        if current_time - next_heartbeat_time > self.register_retry_interval:
-                            SYLogger.info("nacos:服务未注册，尝试重新注册")
-                            self.register_with_retry()
-                            next_heartbeat_time = current_time + self.heartbeat_interval
-                        else:
-                            # 缩短检查间隔
-                            next_heartbeat_time = current_time + \
-                                min(self.heartbeat_interval, 5)
-
-                # 检查线程运行时间，防止线程挂起 - 统一为1小时重置
-                if current_time - thread_start_time > 3600:
-                    SYLogger.info("nacos:心跳线程已运行1小时，重置内部状态")
-                    thread_start_time = current_time
-                    heartbeat_counter = 0
-
-                # 检查是否长时间没有成功心跳
-                if current_time - last_successful_heartbeat > self.heartbeat_interval * 3:
-                    SYLogger.warning(
-                        f"nacos:已超过3个心跳周期({self.heartbeat_interval*3}秒)没有成功发送心跳，尝试重新注册")
-                    self.register_with_retry()
-                    last_successful_heartbeat = current_time
-
-                # 计算休眠时间，避免过度循环
-                sleep_time = next_heartbeat_time - current_time
-                if sleep_time > 0:
-                    SYLogger.info(f"nacos:心跳线程休眠 {sleep_time:.2f} 秒")
-                    self._shutdown_event.wait(sleep_time)
+                        SYLogger.warning(
+                            f"nacos:心跳发送失败，已持续{current_time - self._last_successful_heartbeat:.1f}秒")
                 else:
-                    # 如果已经晚了，立即执行下一次循环
-                    self._shutdown_event.wait(0.1)
-
-            except Exception as e:
-                SYLogger.error(f"nacos:心跳线程异常: {str(e)}")
-                traceback.print_exc()
-                # 发生异常时，增加下次发送间隔
-                next_heartbeat_time = time.time() + 5
-                self._shutdown_event.wait(1)
-
-        SYLogger.info("nacos:心跳线程已停止")
+                    SYLogger.warning("nacos:服务未注册，尝试重新注册")
+                    self._executor.submit(self.register_with_retry)
+            finally:
+                last_heartbeat_time = time.time()  # 更新上次执行时间
 
     def send_heartbeat(self):
-        """发送心跳到Nacos"""
+        """发送心跳并添加超时控制"""
         if not self.ensure_client_connected():
+            SYLogger.warning("nacos:客户端未连接，心跳发送失败")
             return False
 
         try:
-            # 发送心跳
-            result = self.nacos_client.send_heartbeat(
-                service_name=self.service_name,
-                ip=self.real_ip,
-                port=int(self.port),
-                cluster_name="DEFAULT",
-                weight=1.0,
-                metadata={"version": self.version} if self.version else None
-            )
-
-            # 处理返回结果
-            if result and isinstance(result, dict) and result.get('lightBeatEnabled', False):
-                SYLogger.info(
-                    f"nacos:心跳发送成功，Nacos返回: {result}")
-                return True
-            else:
-                SYLogger.warning(
-                    f"nacos:心跳发送失败，Nacos返回: {result}")
-                return False
-
+            # 严格控制心跳超时（3秒）
+            future = self._heartbeat_executor.submit(
+                self._send_heartbeat_internal)
+            result = future.result(timeout=3)  # 超时后抛出异常
+
+            if result:
+                # 只有确认成功才更新时间戳
+                self._last_successful_heartbeat = time.time()
+            return result
         except Exception as e:
             SYLogger.error(f"nacos:发送心跳时发生异常: {e}")
+            self._client_initialized = False  # 强制重连
+            return False
+
+    def _send_heartbeat_internal(self):
+        """实际的心跳发送逻辑"""
+        result = self.nacos_client.send_heartbeat(
+            service_name=self.service_name,
+            ip=self.real_ip,
+            port=int(self.port),
+            cluster_name="DEFAULT",
+            weight=1.0,
+            metadata={"version": self.version} if self.version else None
+        )
+
+        # 处理返回结果
+        if result and isinstance(result, dict) and result.get('lightBeatEnabled', False):
+            SYLogger.info(f"nacos:心跳发送成功，Nacos返回: {result}")
+            return True
+        else:
+            SYLogger.warning(f"nacos:心跳发送失败，Nacos返回: {result}")
             return False
 
     def reconnect_nacos_client(self):
@@ -516,16 +557,18 @@ class NacosService(metaclass=SingletonMeta):
         return self.ensure_client_connected()
 
     def monitor_connection(self):
-        """监控Nacos连接状态，定期检查并在需要时重连"""
-        check_interval = self.nacos_config.get('checkInterval', 10)
+        """优化的连接监控线程，缩短检查间隔"""
+        # 缩短检查间隔（5秒一次）
+        check_interval = self.nacos_config.get('checkInterval', 5)
         thread_start_time = time.time()  # 线程启动时间
         check_counter = 0  # 检查计数器
 
         while not self._shutdown_event.is_set():
             try:
                 current_time = time.time()
+
                 SYLogger.info(
-                    f"nacos:连接监控线程运行中，运行时间: {current_time-thread_start_time:.2f}s, 检查计数: {check_counter}")
+                    f"nacos:连接监控线程运行中，检查间隔: {check_interval}s")
 
                 # 检查客户端连接状态
                 if not self.ensure_client_connected():
@@ -535,19 +578,21 @@ class NacosService(metaclass=SingletonMeta):
                 # 检查服务注册状态
                 current_registered = self.check_service_registered()
 
-                # 更新注册状态并在状态变更时通知心跳线程
-                if current_registered != self.registered:
-                    if current_registered:
-                        self.registered = True
-                        SYLogger.info(f"nacos:服务实例已重新注册")
-                    else:
-                        self.registered = False
-                        SYLogger.warning(f"nacos:服务实例未注册，尝试重新注册")
-                        # 不在锁内调用可能耗时的操作
-                        self._executor.submit(self.register_with_retry)
+                # 带锁更新注册状态
+                with self._state_lock:
+                    if current_registered != self.registered:
+                        if current_registered:
+                            self.registered = True
+                            SYLogger.info(f"nacos:服务实例已重新注册")
+                        else:
+                            self.registered = False
+                            SYLogger.warning(f"nacos:服务实例未注册，尝试重新注册")
+                            # 不在锁内调用可能耗时的操作
+                            self._monitor_executor.submit(
+                                self.register_with_retry)
 
-                # 额外检查：即使状态未变，也定期验证服务是否真的可用
-                if random.random() < 0.2:  # 20%的概率执行深度检查
+                # 20%的概率执行深度检查
+                if random.random() < 0.2:
                     self.verify_registration()
 
                 # 每小时重置一次内部状态
@@ -576,8 +621,9 @@ class NacosService(metaclass=SingletonMeta):
 
     def deregister_service(self):
         """从Nacos注销服务"""
-        if not self.registered or not self._client_initialized:
-            return
+        with self._state_lock:
+            if not self.registered or not self._client_initialized:
+                return
 
         SYLogger.info("nacos:正在注销服务...")
         try:
@@ -587,13 +633,20 @@ class NacosService(metaclass=SingletonMeta):
                 port=int(self.port),
                 cluster_name="DEFAULT"
             )
-            self.registered = False
+            with self._state_lock:
+                self.registered = False
             SYLogger.info(f"nacos:服务 {self.service_name} 已注销")
         except Exception as e:
             SYLogger.error(f"nacos:注销服务时发生错误: {e}")
         finally:
             self._shutdown_event.set()
-            self._executor.shutdown()
+            # 优雅地关闭线程池
+            if self._executor:
+                self._executor.shutdown(wait=True)
+            if self._heartbeat_executor:
+                self._heartbeat_executor.shutdown(wait=True)
+            if self._monitor_executor:
+                self._monitor_executor.shutdown(wait=True)
 
     def handle_signal(self, signum, frame):
         """处理退出信号"""
@@ -658,6 +711,8 @@ class NacosService(metaclass=SingletonMeta):
 
     def _watch_configs(self):
         """配置监听线程"""
+        check_interval = 5  # 固定检查间隔
+
         while not self._shutdown_event.is_set():
             try:
                 for data_id, callback in list(self._config_listeners.items()):
@@ -667,7 +722,7 @@ class NacosService(metaclass=SingletonMeta):
                         self._config_cache[data_id] = new_config
             except Exception as e:
                 SYLogger.error(f"nacos:配置监视线程异常: {str(e)}")
-            self._shutdown_event.wait(5)  # 每5秒检查一次
+            self._shutdown_event.wait(check_interval)  # 检查间隔
 
     def discover_services(self, service_name: str, group: str = "DEFAULT_GROUP", version: str = None) -> List[Dict]:
         """发现服务实例列表 (与Java格式兼容)"""
@@ -677,12 +732,21 @@ class NacosService(metaclass=SingletonMeta):
         return self.get_service_instances(service_name, group, version)
 
     def get_service_instances(self, service_name: str, group: str = "DEFAULT_GROUP", version: str = None) -> List[Dict]:
+        """获取服务实例列表"""
         try:
             namespace_id = self.nacos_config['namespaceId']
             instances = self.nacos_client.list_naming_instance(
-                service_name, "DEFAULT", namespace_id, group, True)
+                service_name,
+                namespace_id=namespace_id,
+                group_name=group,
+                healthy_only=True,
+            )
             if not instances or 'hosts' not in instances:
                 return []
+
+            SYLogger.info(
+                f"nacos:发现 {len(instances.get('hosts', []))} 个 {service_name} 服务实例")
+
             return instances.get('hosts', [])
         except Exception as e:
             SYLogger.error(f"nacos:服务发现失败: {service_name}: {str(e)}")