jettask 0.2.20__py3-none-any.whl → 0.2.24__py3-none-any.whl

jettask/messaging/event_pool.py

@@ -25,13 +25,14 @@ import traceback
 import redis
 from redis import asyncio as aioredis
 
-from ..utils.db_connector import get_sync_redis_client, get_async_redis_client
+from jettask.db.connector import get_sync_redis_client, get_async_redis_client
 
 from ..utils.helpers import get_hostname
 import os
 from jettask.worker.manager import ConsumerManager
 from jettask.worker.recovery import OfflineWorkerRecovery
 from .scanner import DelayedMessageScanner
+from jettask.config.lua_scripts import LUA_SCRIPT_BATCH_SEND_EVENT
 
 logger = logging.getLogger('app')
 
@@ -69,13 +70,22 @@ class EventPool(object):
         self.async_redis_client = async_redis_client
         # 创建用于二进制数据的Redis客户端（用于Stream操作）
         # 直接使用全局客户端实例（单例）
-        self.binary_redis_client = get_sync_redis_client(redis_url, decode_responses=False)
-        self.async_binary_redis_client = get_async_redis_client(redis_url, decode_responses=False)
-        
-        self.queues = queues
+        # 使用无限超时支持PubSub长连接
+        self.binary_redis_client = get_sync_redis_client(redis_url, decode_responses=False, socket_timeout=None)
+        self.async_binary_redis_client = get_async_redis_client(redis_url, decode_responses=False, socket_timeout=None)
+
         self._redis_url = redis_url or 'redis://localhost:6379/0'
         self.redis_prefix = redis_prefix or 'jettask'
         self.app = app  # 保存app引用
+
+        # ✅ 在初始化阶段分离通配符模式和静态队列
+        # self.queues 始终只存储静态队列（或动态发现的队列）
+        # self.wildcard_patterns 存储通配符模式，用于动态队列发现
+        from jettask.utils.queue_matcher import separate_wildcard_and_static_queues
+
+        self.wildcard_patterns, static_queues = separate_wildcard_and_static_queues(queues or [])
+        self.queues = static_queues  # self.queues 只包含静态队列
+        self.wildcard_mode = len(self.wildcard_patterns) > 0  # 是否启用通配符模式
         
         # 初始化消费者管理器
         # consumer_strategy 参数已移除，现在只使用 HEARTBEAT 策略
@@ -168,6 +178,57 @@ class EventPool(object):
         """异步任务放入方法"""
         await event_queue.put(task)
 
+    async def discover_and_update_queues(self, wildcard_patterns: List[str]) -> List[str]:
+        """
+        动态发现并更新队列列表（支持通配符模式）
+
+        根据通配符模式从注册表中匹配队列，并更新 self.queues
+        self.queues 会包含：原有的静态队列 + 新发现的匹配队列
+
+        Args:
+            wildcard_patterns: 通配符模式列表，例如 ['test*']
+                - 'test*' 表示匹配所有test开头的队列
+
+        Returns:
+            List[str]: 新发现的队列列表（只返回新增的，不包括已存在的）
+
+        Example:
+            >>> await ep.discover_and_update_queues(['test*'])
+            ['test1', 'test2']  # 假设这两个是新发现的
+        """
+        from jettask.utils.queue_matcher import discover_matching_queues
+
+        # 1. 从注册表获取所有已注册的队列
+        all_registered_queues = await self.queue_registry.get_all_queues()
+
+        # 将 bytes 转为 str（如果需要）
+        all_registered_queues = {
+            q.decode('utf-8') if isinstance(q, bytes) else q
+            for q in all_registered_queues
+        }
+
+        # 2. 根据通配符模式匹配队列
+        matched_queues = discover_matching_queues(wildcard_patterns, all_registered_queues)
+
+        # 3. 计算新增的队列（matched_queues 中不在 self.queues 中的）
+        current_queues = set(self.queues or [])
+        new_queues = matched_queues - current_queues
+
+        # 4. 更新 self.queues（合并现有队列和新匹配的队列）
+        if new_queues:
+            updated_queues = sorted(current_queues | matched_queues)
+            logger.info(
+                f"队列动态发现: 新增={list(new_queues)}, "
+                f"总计={len(updated_queues)}"
+            )
+            self.queues = updated_queues
+
+            # 为新队列添加停止标志
+            for queue in new_queues:
+                self._queue_stop_flags[queue] = False
+
+        return list(new_queues)
+
     def init_routing(self):
         for queue in self.queues:
             self.solo_agg_task[queue] = defaultdict(list)
@@ -195,40 +256,6 @@ class EventPool(object):
 
     def _batch_send_event_sync(self, prefixed_queue, messages: List[dict], pipe):
         """批量发送事件（同步）"""
-        # 使用Lua脚本批量发送消息并添加自增offset
-        lua_script = """
-        local stream_key = KEYS[1]
-        local prefix = ARGV[1]
-        local results = {}
-
-        -- 使用Hash存储所有队列的offset
-        local offsets_hash = prefix .. ':QUEUE_OFFSETS'
-
-        -- 从stream_key中提取队列名（去掉prefix:QUEUE:前缀）
-        local queue_name = string.gsub(stream_key, '^' .. prefix .. ':QUEUE:', '')
-
-        -- 将队列添加到全局队列注册表（包括所有队列，包括优先级队列）
-        local queues_registry_key = prefix .. ':REGISTRY:QUEUES'
-        redis.call('SADD', queues_registry_key, queue_name)
-
-        -- 从ARGV[2]开始，每个参数是一个消息的data
-        for i = 2, #ARGV do
-            local data = ARGV[i]
-
-            -- 使用HINCRBY原子递增offset（如果不存在会自动创建并设为1）
-            local current_offset = redis.call('HINCRBY', offsets_hash, queue_name, 1)
-
-            -- 添加消息到Stream（包含offset字段）
-            local stream_id = redis.call('XADD', stream_key, '*',
-                'data', data,
-                'offset', current_offset)
-
-            table.insert(results, stream_id)
-        end
-
-        return results
-        """
-
         # 准备Lua脚本参数
         lua_args = [self.redis_prefix.encode() if isinstance(self.redis_prefix, str) else self.redis_prefix]
 
@@ -245,7 +272,7 @@ class EventPool(object):
 
         # 执行Lua脚本
         results = client.eval(
-            lua_script,
+            LUA_SCRIPT_BATCH_SEND_EVENT,
             1,  # 1个KEY
             prefixed_queue,  # KEY[1]: stream key
             *lua_args  # ARGV: prefix, data1, data2, ...
@@ -256,40 +283,6 @@ class EventPool(object):
 
     async def _batch_send_event(self, prefixed_queue, messages: List[dict], pipe):
         """批量发送事件（异步）"""
-        # 使用Lua脚本批量发送消息并添加自增offset
-        lua_script = """
-        local stream_key = KEYS[1]
-        local prefix = ARGV[1]
-        local results = {}
-
-        -- 使用Hash存储所有队列的offset
-        local offsets_hash = prefix .. ':QUEUE_OFFSETS'
-
-        -- 从stream_key中提取队列名（去掉prefix:QUEUE:前缀）
-        local queue_name = string.gsub(stream_key, '^' .. prefix .. ':QUEUE:', '')
-
-        -- 将队列添加到全局队列注册表（包括所有队列，包括优先级队列）
-        local queues_registry_key = prefix .. ':REGISTRY:QUEUES'
-        redis.call('SADD', queues_registry_key, queue_name)
-
-        -- 从ARGV[2]开始，每个参数是一个消息的data
-        for i = 2, #ARGV do
-            local data = ARGV[i]
-
-            -- 使用HINCRBY原子递增offset（如果不存在会自动创建并设为1）
-            local current_offset = redis.call('HINCRBY', offsets_hash, queue_name, 1)
-
-            -- 添加消息到Stream（包含offset字段）
-            local stream_id = redis.call('XADD', stream_key, '*',
-                'data', data,
-                'offset', current_offset)
-
-            table.insert(results, stream_id)
-        end
-
-        return results
-        """
-
         # 准备Lua脚本参数
         lua_args = [self.redis_prefix.encode() if isinstance(self.redis_prefix, str) else self.redis_prefix]
 
@@ -306,7 +299,7 @@ class EventPool(object):
 
         # 执行Lua脚本
         results = await client.eval(
-            lua_script,
+            LUA_SCRIPT_BATCH_SEND_EVENT,
             1,  # 1个KEY
             prefixed_queue,  # KEY[1]: stream key
             *lua_args  # ARGV: prefix, data1, data2, ...
@@ -1263,706 +1256,959 @@ class EventPool(object):
             logger.debug(f"Updated read offset for {field}: {offset}")
         except Exception as e:
             logger.error(f"Error updating read offset: {e}")
-    
-    async def listening_event(self, event_queue: dict, prefetch_multiplier: int = 1):
-        """监听事件 - 为每个task创建独立的consumer group
 
-        Args:
-            event_queue: dict[str, asyncio.Queue] - 按task_name隔离的队列字典
-            prefetch_multiplier: 预取倍数
-        """
-        # 验证参数类型
-        if not isinstance(event_queue, dict):
-            raise TypeError(f"event_queue must be a dict[str, asyncio.Queue], got {type(event_queue)}")
+    # ==================== 通配符队列发现相关方法 ====================
 
-        # 保存 event_queue 字典的引用，供事件驱动的恢复使用
-        self._event_queue_dict = event_queue
+    async def _initial_queue_discovery(self):
+        """初始队列发现（启动时执行一次）- 仅在通配符模式下使用"""
+        if not self.wildcard_mode:
+            return
 
-        logger.info(f"Using task-isolated event queue mode for tasks: {list(event_queue.keys())}")
+        try:
+            logger.info("[QueueDiscovery] Performing initial queue discovery...")
 
-        # 创建一个字典来存储每个队列的延迟任务 - 使用list + Lock更高效
-        for queue in self.queues:
-            self._delayed_tasks_lists[queue] = []
-            self._delayed_tasks_locks[queue] = asyncio.Lock()
+            # 从 QUEUE_REGISTRY 获取所有队列
+            queue_members = await self.async_redis_client.smembers(
+                self._queue_registry_key.encode()
+            )
 
-        # 保存所有创建的任务，以便清理时能够取消它们
-        self._background_tasks = []
+            discovered_queues = set()
+            for queue_bytes in queue_members:
+                queue_name = queue_bytes.decode('utf-8') if isinstance(queue_bytes, bytes) else str(queue_bytes)
+                discovered_queues.add(queue_name)
 
-        # group信息将在每个task监听时记录
-        
-        async def listen_event_by_task(queue, task_name):
-            """为单个任务监听事件"""
-            # 恢复读取历史 pending 消息的逻辑
-            check_backlog = {}  # {queue_name: bool} - 首次读取 pending 消息
-            lastid = {}  # 每个队列的lastid - 首次为 "0"，后续为 ">"
-            consecutive_errors = 0
-            max_consecutive_errors = 5
-
-            # 获取当前task使用的event_queue
-            task_event_queue = event_queue.get(task_name)
-            if not task_event_queue:
-                logger.error(f"No event queue found for task {task_name}")
-                return
+            if not discovered_queues:
+                # 如果注册表为空，尝试从现有数据初始化
+                logger.warning("[QueueDiscovery] QUEUE_REGISTRY is empty, initializing from existing data...")
 
-            # 获取任务对象
-            task = self.app._tasks.get(task_name)
-            if not task:
-                logger.error(f"Task {task_name} not found")
-                return
+                await self.queue_registry.initialize_from_existing_data()
+                discovered_queues = await self.queue_registry.get_all_queues()
 
-            # 定义必要的变量
-            prefixed_queue = self.get_prefixed_queue_name(queue)
-            consumer_name = self.consumer_manager.get_consumer_name(queue)
-            # 使用函数名作为group_name，实现任务隔离（用于后续消息处理）
-            group_name = f"{prefixed_queue}:{task_name}"
+            logger.info(f"[QueueDiscovery] Initial discovery found {len(discovered_queues)} queues: {discovered_queues}")
 
-            # 直接获取所有优先级队列（包括默认队列）
-            priority_queues = await self.get_priority_queues_direct(queue)
-            all_queues = [prefixed_queue] + priority_queues  # 默认队列 + 优先级队列
+            # 更新队列列表
+            self._discovered_queues = discovered_queues
+            # 过滤掉通配符本身，只保留实际队列
+            self.queues = [q for q in discovered_queues if q != '*']
 
-            # 为基础队列创建 consumer group 并记录 group_info
-            base_group_name = await self._ensure_consumer_group_and_record_info(
-                prefixed_queue, task_name, consumer_name
-            )
+            # 更新 ConsumerManager 的队列配置
+            if self.consumer_manager:
+                self.consumer_config['queues'] = self.queues
 
-            # 为优先级队列创建 consumer group（共享基础队列的 group_name）
-            for pq in priority_queues:
-                await self._ensure_consumer_group_and_record_info(
-                    pq, task_name, consumer_name, base_group_name=base_group_name
+        except Exception as e:
+            logger.error(f"[QueueDiscovery] Initial discovery failed: {e}", exc_info=True)
+            self._discovered_queues = set()
+            self.queues = []
+
+    async def _discover_queues_loop(self):
+        """定期发现新队列（仅在通配符模式下运行）"""
+        if not self.wildcard_mode:
+            return
+
+        logger.info("[QueueDiscovery] Starting wildcard queue discovery loop...")
+
+        while not self._stop_reading:
+            try:
+                # 从 QUEUE_REGISTRY 获取所有队列
+                queue_members = await self.async_redis_client.smembers(
+                    self._queue_registry_key.encode()
                 )
 
-            # ✅ 初始化每个队列：首次读取 pending 消息（从 "0" 开始）
-            for q in all_queues:
-                lastid[q] = "0"  # 首次读取历史消息
-                check_backlog[q] = True  # 首次读取 pending 消息
-            
-            # 获取该队列的延迟任务列表和锁
-            delayed_list = self._delayed_tasks_lists.get(queue)
-            delayed_lock = self._delayed_tasks_locks.get(queue)
-            
-            # 记录上次优先级队列更新时间和上次group_info检查时间
-            last_priority_update = time.time()
-            last_group_info_check = time.time()
-
-            while not self._stop_reading:
-                # 定期直接从Redis获取优先级队列（每1秒检查一次）
-                current_time = time.time()
-                if current_time - last_priority_update >= 1:  # 简化为固定1秒间隔
-                    new_priority_queues = await self.get_priority_queues_direct(queue)
-
-                    # 如果优先级队列有变化，更新本地变量
-                    if new_priority_queues != priority_queues:
-                        logger.debug(f"Priority queues updated for {queue}: {priority_queues} -> {new_priority_queues}")
-                        priority_queues = new_priority_queues
-                        all_queues = [prefixed_queue] + priority_queues
-
-                        # 为新的优先级队列创建consumer group（共享基础队列的 group_name）
-                        for q in all_queues:
-                            if q not in lastid:  # 这是新队列
-                                await self._ensure_consumer_group_and_record_info(
-                                    q, task_name, consumer_name, base_group_name=group_name
-                                )
-                                logger.debug(f"Ensured consumer group for new priority queue {q}")
+                current_queues = set()
+                for queue_bytes in queue_members:
+                    queue_name = queue_bytes.decode('utf-8') if isinstance(queue_bytes, bytes) else str(queue_bytes)
+                    current_queues.add(queue_name)
 
-                                # ✅ 初始化新队列：读取历史 pending 消息
-                                lastid[q] = "0"
-                                check_backlog[q] = True
+                # 发现新队列
+                new_queues = current_queues - self._discovered_queues
 
-                    last_priority_update = current_time
+                if new_queues:
+                    logger.info(f"[QueueDiscovery] Discovered new queues: {new_queues}")
 
-                # 定期检查并恢复group_info（每10秒检查一次）
-                if current_time - last_group_info_check >= 10:
-                    # 检查worker key中是否缺失group_info
-                    if self.consumer_manager:
-                        worker_key = self.consumer_manager._heartbeat_strategy._worker_key
-                        try:
-                            # 检查第一个队列的group_info是否存在
-                            first_queue = all_queues[0] if all_queues else prefixed_queue
-                            first_group_name = f"{first_queue}:{task_name}"
-                            field_name = f"group_info:{first_group_name}"
+                    # 为新队列创建监听任务
+                    await self._start_listeners_for_new_queues(new_queues)
 
-                            group_info_exists = await self.async_redis_client.hexists(worker_key, field_name)
+                    # 更新已发现队列集合
+                    self._discovered_queues.update(new_queues)
 
-                            # 如果group_info不存在，说明worker key可能被重建了，需要恢复group_info
-                            if not group_info_exists:
-                                logger.info(f"Detected missing group_info for task {task_name}, restoring...")
+                    # 更新 self.queues（过滤掉通配符）
+                    self.queues = [q for q in self._discovered_queues if q != '*']
 
-                                # 恢复基础队列的 group_info
-                                await self._ensure_consumer_group_and_record_info(prefixed_queue, task_name, consumer_name)
+                    # 更新 ConsumerManager 的队列配置
+                    if self.consumer_manager:
+                        self.consumer_config['queues'] = self.queues
 
-                                # 为优先级队列重新创建 consumer group（共享基础队列的 group_name）
-                                for pq in priority_queues:
-                                    await self._ensure_consumer_group_and_record_info(
-                                        pq, task_name, consumer_name, base_group_name=group_name
-                                    )
+                # 检查已删除的队列
+                removed_queues = self._discovered_queues - current_queues
+                if removed_queues:
+                    logger.info(f"[QueueDiscovery] Queues removed: {removed_queues}")
+                    self._discovered_queues -= removed_queues
+                    self.queues = [q for q in self._discovered_queues if q != '*']
 
-                                logger.info(f"Restored group_info and consumer groups for {len(all_queues)} queues for task {task_name}")
-                        except Exception as e:
-                            logger.error(f"Error checking/restoring group_info: {e}", exc_info=True)
+                    # 更新 ConsumerManager 的队列配置
+                    if self.consumer_manager:
+                        self.consumer_config['queues'] = self.queues
 
-                    last_group_info_check = current_time
-                
-                # 批量获取并处理延迟任务（使用list更高效）
-                if delayed_list:
-                    # 原子地交换list内容
-                    async with delayed_lock:
-                        if delayed_list:
-                            # 快速拷贝并清空原list
-                            tasks_to_process = delayed_list.copy()
-                            delayed_list.clear()
-                        else:
-                            tasks_to_process = []
-                    
-                    # 处理所有延迟任务
-                    if tasks_to_process:
-                        my_tasks = []  # 属于当前task的任务
-                        other_tasks = []  # 属于其他task的任务
-                        
-                        for delayed_task in tasks_to_process:
-                            # Scanner 返回的格式：{'event_id': '...', 'queue': '...'}
-                            # 没有 data 字段，需要通过 XCLAIM 获取
-
-                            # 注意：新版本Scanner只返回消息ID，不返回数据
-                            # 数据将在后续通过XCLAIM获取
-                            task_data = delayed_task.get('data', None)
-
-                            # 如果task_data存在（兼容旧版本Scanner）
-                            if task_data:
-                                if isinstance(task_data, str):
-                                    import json
-                                    task_data = json.loads(task_data)
-
-                                # 检查消息是否指定了目标task
-                                target_tasks = task_data.get('_target_tasks', None)
-                                if target_tasks and task_name not in target_tasks:
-                                    # 这个消息不是给当前task的
-                                    other_tasks.append(delayed_task)
-                                    continue
+                # 每10秒检查一次
+                await asyncio.sleep(10)
 
-                            # 当前task处理这个任务
-                            # task_data可能为None，会在后续通过XCLAIM获取
-                            my_tasks.append((delayed_task, task_data))
-                        
-                        # 处理属于当前task的所有任务
-                        # 按队列分组延迟任务的 offset（因为可能来自不同的优先级队列）
-                        max_offsets_by_queue = {}
+            except Exception as e:
+                logger.error(f"[QueueDiscovery] Error in discovery loop: {e}", exc_info=True)
+                await asyncio.sleep(10)
 
-                        for delayed_task, task_data in my_tasks:
-                            event_id = delayed_task.get('event_id', f"delayed-{time.time()}")
+    async def _start_listeners_for_new_queues(self, new_queues: set):
+        """为新发现的队列启动监听任务
 
-                            # 获取任务来自哪个队列（可能包含优先级后缀）
-                            task_queue = delayed_task.get('queue', queue)
+        Args:
+            new_queues: 新发现的队列集合
+        """
+        if not (self.app and hasattr(self.app, '_tasks_by_queue')):
+            logger.error("[QueueDiscovery] No app or tasks registered")
+            return
 
-                            # 如果task_data为None，说明Scanner只返回了消息ID
-                            # 需要使用XCLAIM从Stream中claim消息并转移所有权
-                            if task_data is None:
-                                prefixed_queue = self.get_prefixed_queue_name(task_queue)
-                                try:
-                                    # 使用XCLAIM转移消息所有权
-                                    # min_idle_time设为0，强制claim
-                                    claimed_messages = await self.async_binary_redis_client.xclaim(
-                                        name=prefixed_queue,
-                                        groupname=group_name,
-                                        consumername=consumer_name,
-                                        min_idle_time=0,  # 立即claim，不管idle时间
-                                        message_ids=[event_id]
-                                    )
-
-                                    if not claimed_messages:
-                                        logger.warning(f"Failed to claim delayed message {event_id} from queue {task_queue}")
-                                        continue
+        # 获取通配符任务（queue="*" 的任务）
+        wildcard_tasks = self.app._tasks_by_queue.get('*', [])
 
-                                    # 解析claimed消息
-                                    claimed_msg = claimed_messages[0]  # [(stream_id, fields)]
-                                    if isinstance(claimed_msg, (list, tuple)) and len(claimed_msg) >= 2:
-                                        fields = claimed_msg[1]
-
-                                        # 将fields转换为字典
-                                        task_data_dict = {}
-                                        if isinstance(fields, dict):
-                                            task_data_dict = fields
-                                        elif isinstance(fields, list):
-                                            for j in range(0, len(fields), 2):
-                                                if j + 1 < len(fields):
-                                                    key = fields[j]
-                                                    value = fields[j + 1]
-                                                    task_data_dict[key] = value
-
-                                        # 解析data字段
-                                        data_field = task_data_dict.get('data') or task_data_dict.get(b'data')
-                                        if data_field:
-                                            task_data = loads_str(data_field)
-
-                                            # 提取 offset 字段（关键：确保延迟任务的 offset 能被记录）
-                                            offset_field = task_data_dict.get('offset') or task_data_dict.get(b'offset')
-                                            if offset_field:
-                                                try:
-                                                    offset_value = int(offset_field) if isinstance(offset_field, (int, str)) else int(offset_field.decode())
-                                                    task_data['offset'] = offset_value
-                                                except (ValueError, TypeError, AttributeError):
-                                                    logger.debug(f"Failed to extract offset from claimed message {event_id}")
-                                        else:
-                                            logger.warning(f"No data field in claimed message {event_id}")
-                                            continue
-                                    else:
-                                        logger.warning(f"Invalid claimed message format for {event_id}")
-                                        continue
+        if not wildcard_tasks:
+            logger.warning("[QueueDiscovery] No wildcard tasks registered (queue='*')")
+            return
 
-                                except Exception as e:
-                                    logger.error(f"Error claiming delayed message {event_id}: {e}", exc_info=True)
-                                    continue
+        # 获取当前的 event_queue 字典（从 listening_event 传递过来的）
+        # 注意：这需要在 listening_event 中保存 event_queue 的引用
+        event_queue_dict = getattr(self, '_event_queue_dict', None)
+        if not event_queue_dict:
+            logger.error("[QueueDiscovery] Event queue dict not found")
+            return
 
-                            task_data['_task_name'] = task_name
+        for queue in new_queues:
+            # 初始化延迟任务列表和锁
+            if queue not in self._delayed_tasks_lists:
+                self._delayed_tasks_lists[queue] = []
+                self._delayed_tasks_locks[queue] = asyncio.Lock()
 
-                            # 记录延迟精度（用于调试）
-                            if 'execute_at' in task_data:
-                                delay_error = time.time() - task_data['execute_at']
-                                if abs(delay_error) > 0.1:  # 超过100ms才记录
-                                    logger.debug(f'延迟任务 {event_id} 执行误差: {delay_error*1000:.1f}ms')
+            # 为新队列注册延迟任务回调
+            import functools
+            callback = functools.partial(self._handle_expired_tasks, queue)
+            self.delayed_scanner.register_callback(queue, callback)
 
-                            # 收集每个队列的最大offset
-                            if 'offset' in task_data:
-                                try:
-                                    message_offset = int(task_data['offset'])
-                                    if task_queue not in max_offsets_by_queue or message_offset > max_offsets_by_queue[task_queue]:
-                                        max_offsets_by_queue[task_queue] = message_offset
-                                except (ValueError, TypeError):
-                                    pass
+            # 更新延迟扫描器监听的队列列表（添加新队列）
+            # 注意：DelayedMessageScanner 需要支持动态添加队列
+            if hasattr(self.delayed_scanner, 'add_queue'):
+                await self.delayed_scanner.add_queue(queue)
+
+            # 为每个通配符任务创建监听器
+            for task_name in wildcard_tasks:
+                logger.info(f"[QueueDiscovery] Starting listener: {task_name} on queue: {queue}")
+
+                # 创建监听任务（复用 listening_event 中的 listen_event_by_task 逻辑）
+                # 注意：这里需要能够访问 listen_event_by_task 函数
+                # 我们将在 listening_event 中将其保存为实例方法
+                if hasattr(self, '_listen_event_by_task'):
+                    task = asyncio.create_task(
+                        self._listen_event_by_task(queue, task_name)
+                    )
+                    self._background_tasks.append(task)
 
-                            # 所有队列（包括优先级队列）都使用基础队列的 group_name
-                            result = self._process_message_common(
-                                event_id, task_data, task_queue, task_event_queue,
-                                is_async=True, consumer_name=consumer_name, group_name=group_name
-                            )
-                            if isinstance(result, tuple) and result[0] == 'async_put':
-                                await self._async_put_task(task_event_queue, result[1])
+            # 为新队列启动离线worker恢复
+            offline_task = asyncio.create_task(
+                self._start_offline_worker_processor_with_restart(queue)
+            )
+            self._background_tasks.append(offline_task)
 
-                        # 批量更新每个队列的最大offset（所有队列使用同一个 group_name）
-                        for task_queue, max_offset in max_offsets_by_queue.items():
-                            asyncio.create_task(self._update_read_offset(task_queue, group_name, max_offset))
-                        
-                        # 把不属于当前task的任务放回list
-                        if other_tasks:
-                            async with delayed_lock:
-                                delayed_list.extend(other_tasks)
-                
-                # 处理正常的Stream消息（支持优先级队列）
-                # 实现真正的优先级消费：
-                # 1. 先检查event_queue是否已满
-                # 2. 优先从高优先级队列读取
-                # 3. 只有高优先级队列空了才读取低优先级
-                # 4. 不超过prefetch_multiplier限制
-                
-                # 检查内存队列是否已满
-                current_queue_size = task_event_queue.qsize() if hasattr(task_event_queue, 'qsize') else 0
-                if current_queue_size >= prefetch_multiplier:
-                    # 内存队列已满，等待处理
-                    await asyncio.sleep(0.01)  # 短暂等待
-                    continue
-                
-                messages = []
-                messages_needed = prefetch_multiplier - current_queue_size  # 还能读取的消息数
-                
-                if messages_needed <= 0:
-                    # 不需要读取更多消息
-                    await asyncio.sleep(0.01)
-                    continue
+    async def _handle_expired_tasks(self, queue: str, tasks: list):
+        """处理到期的延迟任务（回调函数）
+
+        Args:
+            queue: 队列名称
+            tasks: 到期的任务列表
+        """
+        if tasks:
+            # 确保延迟任务列表已初始化
+            if queue not in self._delayed_tasks_lists:
+                self._delayed_tasks_lists[queue] = []
+                self._delayed_tasks_locks[queue] = asyncio.Lock()
+
+            async with self._delayed_tasks_locks[queue]:
+                self._delayed_tasks_lists[queue].extend(tasks)
+
+    # ==================== 结束：通配符队列发现相关方法 ====================
+
+    # 为每个队列注册延迟任务回调
+    async def handle_expired_tasks(self, queue: str, tasks: list):
+        """处理到期的延迟任务"""
+        if tasks:
+            async with self._delayed_tasks_locks[queue]:
+                self._delayed_tasks_lists[queue].extend(tasks)
                 
-                # 优化：预先检查哪些队列有待读取的消息，避免在空队列上浪费时间
-                # ✅ 但如果队列需要读取 pending 消息（check_backlog=True），则跳过该队列的 offset 检查
-                queues_with_messages = []
+    async def listen_event_by_task(self, event_queue, queue, task_name, prefetch_multiplier):
+        """为单个任务监听事件"""
+        # 恢复读取历史 pending 消息的逻辑
+        check_backlog = {}  # {queue_name: bool} - 首次读取 pending 消息
+        lastid = {}  # 每个队列的lastid - 首次为 "0"，后续为 ">"
+        consecutive_errors = 0
+        max_consecutive_errors = 5
+
+        # 获取当前task使用的event_queue
+        task_event_queue = event_queue.get(task_name)
+        if not task_event_queue:
+            logger.error(f"No event queue found for task {task_name}")
+            return
 
-                try:
-                    # 批量获取已发送和已读取的offset
-                    queue_offsets_key = f"{self.redis_prefix}:QUEUE_OFFSETS"
-                    read_offsets_key = f"{self.redis_prefix}:READ_OFFSETS"
+        # 获取任务对象
+        task = self.app._tasks.get(task_name)
+        if not task:
+            logger.error(f"Task {task_name} not found")
+            return
 
-                    # 使用pipeline批量获取offset
-                    pipe = self.async_redis_client.pipeline()
+        # 定义必要的变量
+        prefixed_queue = self.get_prefixed_queue_name(queue)
+        consumer_name = self.consumer_manager.get_consumer_name(queue)
+        # 使用函数名作为group_name，实现任务隔离（用于后续消息处理）
+        group_name = f"{prefixed_queue}:{task_name}"
 
-                    # 获取所有队列的已发送offset
-                    for q in all_queues:
-                        # 从队列名中提取实际的队列名（去掉前缀）
-                        actual_queue = q.replace(f"{self.redis_prefix}:QUEUE:", "")
-                        pipe.hget(queue_offsets_key, actual_queue)
+        # 直接获取所有优先级队列（包括默认队列）
+        priority_queues = await self.get_priority_queues_direct(queue)
+        all_queues = [prefixed_queue] + priority_queues  # 默认队列 + 优先级队列
 
-                    # 提取 task_name（从 group_name 中）
-                    task_name = group_name.split(':')[-1]
+        # 为基础队列创建 consumer group 并记录 group_info
+        base_group_name = await self._ensure_consumer_group_and_record_info(
+            prefixed_queue, task_name, consumer_name
+        )
+
+        # 为优先级队列创建 consumer group（共享基础队列的 group_name）
+        for pq in priority_queues:
+            await self._ensure_consumer_group_and_record_info(
+                pq, task_name, consumer_name, base_group_name=base_group_name
+            )
 
-                    # 获取所有队列的已读取offset
+        # ✅ 初始化每个队列：首次读取 pending 消息（从 "0" 开始）
+        for q in all_queues:
+            lastid[q] = "0"  # 首次读取历史消息
+            check_backlog[q] = True  # 首次读取 pending 消息
+        
+        # 获取该队列的延迟任务列表和锁
+        delayed_list = self._delayed_tasks_lists.get(queue)
+        delayed_lock = self._delayed_tasks_locks.get(queue)
+        
+        # 记录上次优先级队列更新时间和上次group_info检查时间
+        last_priority_update = time.time()
+        last_group_info_check = time.time()
+
+        while not self._stop_reading:
+            # 定期直接从Redis获取优先级队列（每1秒检查一次）
+            current_time = time.time()
+            if current_time - last_priority_update >= 1:  # 简化为固定1秒间隔
+                new_priority_queues = await self.get_priority_queues_direct(queue)
+
+                # 如果优先级队列有变化，更新本地变量
+                if new_priority_queues != priority_queues:
+                    logger.debug(f"Priority queues updated for {queue}: {priority_queues} -> {new_priority_queues}")
+                    priority_queues = new_priority_queues
+                    all_queues = [prefixed_queue] + priority_queues
+
+                    # 为新的优先级队列创建consumer group（共享基础队列的 group_name）
                     for q in all_queues:
-                        actual_queue = q.replace(f"{self.redis_prefix}:QUEUE:", "")
-                        # field 格式：队列名（含优先级）:任务名
-                        field = f"{actual_queue}:{task_name}"
-                        pipe.hget(read_offsets_key, field)
-
-                    results = await pipe.execute()
-
-                    # 分析结果，确定哪些队列有待读取的消息
-                    half_len = len(all_queues)
-                    for i, q in enumerate(all_queues):
-                        # ✅ 如果该队列需要读取 pending 消息，直接加入列表，跳过 offset 检查
-                        if check_backlog.get(q, False):
-                            queues_with_messages.append(q)
-                            logger.debug(f"Queue {q} needs to read pending messages, skipping offset check")
-                            continue
+                        if q not in lastid:  # 这是新队列
+                            await self._ensure_consumer_group_and_record_info(
+                                q, task_name, consumer_name, base_group_name=group_name
+                            )
+                            logger.debug(f"Ensured consumer group for new priority queue {q}")
 
-                        sent_offset = results[i]  # 已发送的offset
-                        read_offset = results[half_len + i]  # 已读取的offset
+                            # ✅ 初始化新队列：读取历史 pending 消息
+                            lastid[q] = "0"
+                            check_backlog[q] = True
 
-                        # 转换为整数
-                        sent = int(sent_offset) if sent_offset else 0
-                        read = int(read_offset) if read_offset else 0
+                last_priority_update = current_time
 
-                        # 如果已发送的offset大于已读取的offset，说明有消息待读取
-                        if sent > read:
-                            queues_with_messages.append(q)
-                            logger.debug(f"Queue {q} has {sent - read} unread messages (sent={sent}, read={read})")
+            # 定期检查并恢复group_info（每10秒检查一次）
+            if current_time - last_group_info_check >= 10:
+                # 检查worker key中是否缺失group_info
+                if self.consumer_manager:
+                    worker_key = self.consumer_manager._heartbeat_strategy._worker_key
+                    try:
+                        # 检查第一个队列的group_info是否存在
+                        first_queue = all_queues[0] if all_queues else prefixed_queue
+                        first_group_name = f"{first_queue}:{task_name}"
+                        field_name = f"group_info:{first_group_name}"
 
-                    # 如果没有队列有消息，记录下来（不再使用原始队列列表避免空读）
-                    if not queues_with_messages:
-                        logger.debug("No queues have unread messages, will wait for new messages")
+                        group_info_exists = await self.async_redis_client.hexists(worker_key, field_name)
 
-                except Exception as e:
-                    # 出错时回退到原始逻辑
-                    logger.debug(f"Failed to check queue offsets: {e}")
-                    queues_with_messages = all_queues
+                        # 如果group_info不存在，说明worker key可能被重建了，需要恢复group_info
+                        if not group_info_exists:
+                            logger.info(f"Detected missing group_info for task {task_name}, restoring...")
+
+                            # 恢复基础队列的 group_info
+                            await self._ensure_consumer_group_and_record_info(prefixed_queue, task_name, consumer_name)
+
+                            # 为优先级队列重新创建 consumer group（共享基础队列的 group_name）
+                            for pq in priority_queues:
+                                await self._ensure_consumer_group_and_record_info(
+                                    pq, task_name, consumer_name, base_group_name=group_name
+                                )
+
+                            logger.info(f"Restored group_info and consumer groups for {len(all_queues)} queues for task {task_name}")
+                    except Exception as e:
+                        logger.error(f"Error checking/restoring group_info: {e}", exc_info=True)
+
+                last_group_info_check = current_time
+            
+            # 批量获取并处理延迟任务（使用list更高效）
+            if delayed_list:
+                # 原子地交换list内容
+                async with delayed_lock:
+                    if delayed_list:
+                        # 快速拷贝并清空原list
+                        tasks_to_process = delayed_list.copy()
+                        delayed_list.clear()
+                    else:
+                        tasks_to_process = []
                 
-                # print(f'{queues_with_messages=}')
-                # 按优先级顺序读取有消息的队列
-                for q in queues_with_messages:
-                    if messages_needed <= 0:
-                        break  # 已经读取足够的消息
+                # 处理所有延迟任务
+                if tasks_to_process:
+                    my_tasks = []  # 属于当前task的任务
+                    other_tasks = []  # 属于其他task的任务
                     
-                    q_bytes = q.encode() if isinstance(q, str) else q
-                    # 针对具体队列检查是否需要读取历史消息
-                    if check_backlog.get(q, True):
-                        myid = lastid.get(q, "0-0")
-                    else:
-                        myid = ">"
-                    myid_bytes = myid.encode() if isinstance(myid, str) else myid
+                    for delayed_task in tasks_to_process:
+                        # Scanner 返回的格式：{'event_id': '...', 'queue': '...'}
+                        # 没有 data 字段，需要通过 XCLAIM 获取
+
+                        # 注意：新版本Scanner只返回消息ID，不返回数据
+                        # 数据将在后续通过XCLAIM获取
+                        task_data = delayed_task.get('data', None)
+
+                        # 如果task_data存在（兼容旧版本Scanner）
+                        if task_data:
+                            if isinstance(task_data, str):
+                                import json
+                                task_data = json.loads(task_data)
+
+                            # 检查消息是否指定了目标task
+                            target_tasks = task_data.get('_target_tasks', None)
+                            if target_tasks and task_name not in target_tasks:
+                                # 这个消息不是给当前task的
+                                other_tasks.append(delayed_task)
+                                continue
+
+                        # 当前task处理这个任务
+                        # task_data可能为None，会在后续通过XCLAIM获取
+                        my_tasks.append((delayed_task, task_data))
                     
-                    try:
-                        # print(f'{myid_bytes=} {consumer_name=} {check_backlog=} {q_bytes=}')
-                        # 所有队列（包括优先级队列）都使用基础队列的 group_name
-                        # 从当前优先级队列读取（最多读取messages_needed个）
-                        q_messages = await self.async_binary_redis_client.xreadgroup(
-                            groupname=group_name,
-                            consumername=consumer_name,
-                            streams={q_bytes: myid_bytes},
-                            count=messages_needed,  # 只读取需要的数量
-                            block=100  # 非阻塞
-                        )
-                        if q_messages:
-                            logger.info(f"Read messages from {q}: {len(q_messages[0][1]) if q_messages else 0} messages")
-                            # if check_backlog.get(q, True):
-                            #     print(f'先处理历史消息：{q_bytes=} {group_name=} {q_messages=}')
-                            # 记录从哪个队列读取的
-                            messages.extend(q_messages)
-                            messages_read = len(q_messages[0][1]) if q_messages else 0
-                            messages_needed -= messages_read
-                            
-                            # 如果高优先级队列还有消息，继续从该队列读取
-                            # 直到该队列空了或者达到prefetch限制
-                            if messages_read > 0 and messages_needed > 0:
-                                # 该队列可能还有更多消息，下次循环继续优先从这个队列读
-                                # 但现在先处理已读取的消息
-                                break  # 跳出for循环，处理已有消息
-                            
-                    except Exception as e:
-                        if "NOGROUP" in str(e):
-                            # consumer group 不存在（可能是 Redis 被清空了），重新创建
-                            logger.warning(f"NOGROUP error for queue {q}, recreating consumer group...")
+                    # 处理属于当前task的所有任务
+                    # 按队列分组延迟任务的 offset（因为可能来自不同的优先级队列）
+                    max_offsets_by_queue = {}
+
+                    for delayed_task, task_data in my_tasks:
+                        event_id = delayed_task.get('event_id', f"delayed-{time.time()}")
+
+                        # 获取任务来自哪个队列（可能包含优先级后缀）
+                        task_queue = delayed_task.get('queue', queue)
+
+                        # 如果task_data为None，说明Scanner只返回了消息ID
+                        # 需要使用XCLAIM从Stream中claim消息并转移所有权
+                        if task_data is None:
+                            prefixed_queue = self.get_prefixed_queue_name(task_queue)
                             try:
-                                # 为队列创建 consumer group（共享基础队列的 group_name）
-                                await self._ensure_consumer_group_and_record_info(
-                                    q, task_name, consumer_name, base_group_name=group_name
+                                # 使用XCLAIM转移消息所有权
+                                # min_idle_time设为0，强制claim
+                                claimed_messages = await self.async_binary_redis_client.xclaim(
+                                    name=prefixed_queue,
+                                    groupname=group_name,
+                                    consumername=consumer_name,
+                                    min_idle_time=0,  # 立即claim，不管idle时间
+                                    message_ids=[event_id]
                                 )
-                                logger.info(f"Recreated consumer group for queue {q}")
-
-                                # 重新初始化这个队列的 lastid 和 check_backlog
-                                lastid[q] = "0"
-                                check_backlog[q] = True
-
-                                # 确保这个队列在 all_queues 中（可能因 Redis 清空而丢失）
-                                if q not in all_queues:
-                                    all_queues.append(q)
-                                    # 同时更新 priority_queues（如果是优先级队列）
-                                    if q != prefixed_queue and q not in priority_queues:
-                                        priority_queues.append(q)
-                                        logger.info(f"Re-added queue {q} to all_queues after NOGROUP recovery")
-                            except Exception as recreate_error:
-                                logger.error(f"Failed to recreate consumer group for {q}: {recreate_error}")
-                        else:
-                            logger.debug(f"Error reading from queue {q}: {e}")
+
+                                if not claimed_messages:
+                                    logger.warning(f"Failed to claim delayed message {event_id} from queue {task_queue}")
+                                    continue
+
+                                # 解析claimed消息
+                                claimed_msg = claimed_messages[0]  # [(stream_id, fields)]
+                                if isinstance(claimed_msg, (list, tuple)) and len(claimed_msg) >= 2:
+                                    fields = claimed_msg[1]
+
+                                    # 将fields转换为字典
+                                    task_data_dict = {}
+                                    if isinstance(fields, dict):
+                                        task_data_dict = fields
+                                    elif isinstance(fields, list):
+                                        for j in range(0, len(fields), 2):
+                                            if j + 1 < len(fields):
+                                                key = fields[j]
+                                                value = fields[j + 1]
+                                                task_data_dict[key] = value
+
+                                    # 解析data字段
+                                    data_field = task_data_dict.get('data') or task_data_dict.get(b'data')
+                                    if data_field:
+                                        task_data = loads_str(data_field)
+
+                                        # 提取 offset 字段（关键：确保延迟任务的 offset 能被记录）
+                                        offset_field = task_data_dict.get('offset') or task_data_dict.get(b'offset')
+                                        if offset_field:
+                                            try:
+                                                offset_value = int(offset_field) if isinstance(offset_field, (int, str)) else int(offset_field.decode())
+                                                task_data['offset'] = offset_value
+                                            except (ValueError, TypeError, AttributeError):
+                                                logger.debug(f"Failed to extract offset from claimed message {event_id}")
+                                    else:
+                                        logger.warning(f"No data field in claimed message {event_id}")
+                                        continue
+                                else:
+                                    logger.warning(f"Invalid claimed message format for {event_id}")
+                                    continue
+
+                            except Exception as e:
+                                logger.error(f"Error claiming delayed message {event_id}: {e}", exc_info=True)
+                                continue
+
+                        task_data['_task_name'] = task_name
+
+                        # 记录延迟精度（用于调试）
+                        if 'execute_at' in task_data:
+                            delay_error = time.time() - task_data['execute_at']
+                            if abs(delay_error) > 0.1:  # 超过100ms才记录
+                                logger.debug(f'延迟任务 {event_id} 执行误差: {delay_error*1000:.1f}ms')
+
+                        # 收集每个队列的最大offset
+                        if 'offset' in task_data:
+                            try:
+                                message_offset = int(task_data['offset'])
+                                if task_queue not in max_offsets_by_queue or message_offset > max_offsets_by_queue[task_queue]:
+                                    max_offsets_by_queue[task_queue] = message_offset
+                            except (ValueError, TypeError):
+                                pass
+
+                        # 所有队列（包括优先级队列）都使用基础队列的 group_name
+                        result = self._process_message_common(
+                            event_id, task_data, task_queue, task_event_queue,
+                            is_async=True, consumer_name=consumer_name, group_name=group_name
+                        )
+                        if isinstance(result, tuple) and result[0] == 'async_put':
+                            await self._async_put_task(task_event_queue, result[1])
+
+                    # 批量更新每个队列的最大offset（所有队列使用同一个 group_name）
+                    for task_queue, max_offset in max_offsets_by_queue.items():
+                        asyncio.create_task(self._update_read_offset(task_queue, group_name, max_offset))
+                    
+                    # 把不属于当前task的任务放回list
+                    if other_tasks:
+                        async with delayed_lock:
+                            delayed_list.extend(other_tasks)
+            
+            # 处理正常的Stream消息（支持优先级队列）
+            # 实现真正的优先级消费：
+            # 1. 先检查event_queue是否已满
+            # 2. 优先从高优先级队列读取
+            # 3. 只有高优先级队列空了才读取低优先级
+            # 4. 不超过prefetch_multiplier限制
+            
+            # 检查内存队列是否已满
+            current_queue_size = task_event_queue.qsize() if hasattr(task_event_queue, 'qsize') else 0
+            if current_queue_size >= prefetch_multiplier:
+                # 内存队列已满，等待处理
+                await asyncio.sleep(0.01)  # 短暂等待
+                continue
+            
+            messages = []
+            messages_needed = prefetch_multiplier - current_queue_size  # 还能读取的消息数
+            
+            if messages_needed <= 0:
+                # 不需要读取更多消息
+                await asyncio.sleep(0.01)
+                continue
+            
+            # 优化：预先检查哪些队列有待读取的消息，避免在空队列上浪费时间
+            # ✅ 但如果队列需要读取 pending 消息（check_backlog=True），则跳过该队列的 offset 检查
+            queues_with_messages = []
+
+            try:
+                # 批量获取已发送和已读取的offset
+                queue_offsets_key = f"{self.redis_prefix}:QUEUE_OFFSETS"
+                read_offsets_key = f"{self.redis_prefix}:READ_OFFSETS"
+
+                # 使用pipeline批量获取offset
+                pipe = self.async_redis_client.pipeline()
+
+                # 获取所有队列的已发送offset
+                for q in all_queues:
+                    # 从队列名中提取实际的队列名（去掉前缀）
+                    actual_queue = q.replace(f"{self.redis_prefix}:QUEUE:", "")
+                    pipe.hget(queue_offsets_key, actual_queue)
+
+                # 提取 task_name（从 group_name 中）
+                task_name = group_name.split(':')[-1]
+
+                # 获取所有队列的已读取offset
+                for q in all_queues:
+                    actual_queue = q.replace(f"{self.redis_prefix}:QUEUE:", "")
+                    # field 格式：队列名（含优先级）:任务名
+                    field = f"{actual_queue}:{task_name}"
+                    pipe.hget(read_offsets_key, field)
+
+                results = await pipe.execute()
+
+                # 分析结果，确定哪些队列有待读取的消息
+                half_len = len(all_queues)
+                for i, q in enumerate(all_queues):
+                    # ✅ 如果该队列需要读取 pending 消息，直接加入列表，跳过 offset 检查
+                    if check_backlog.get(q, False):
+                        queues_with_messages.append(q)
+                        logger.debug(f"Queue {q} needs to read pending messages, skipping offset check")
                         continue
-    
+
+                    sent_offset = results[i]  # 已发送的offset
+                    read_offset = results[half_len + i]  # 已读取的offset
+
+                    # 转换为整数
+                    sent = int(sent_offset) if sent_offset else 0
+                    read = int(read_offset) if read_offset else 0
+
+                    # 如果已发送的offset大于已读取的offset，说明有消息待读取
+                    if sent > read:
+                        queues_with_messages.append(q)
+                        logger.debug(f"Queue {q} has {sent - read} unread messages (sent={sent}, read={read})")
+
+                # 如果没有队列有消息，记录下来（不再使用原始队列列表避免空读）
+                if not queues_with_messages:
+                    logger.debug("No queues have unread messages, will wait for new messages")
+
+            except Exception as e:
+                # 出错时回退到原始逻辑
+                logger.debug(f"Failed to check queue offsets: {e}")
+                queues_with_messages = all_queues
+            
+            # print(f'{queues_with_messages=}')
+            # 按优先级顺序读取有消息的队列
+            for q in queues_with_messages:
+                if messages_needed <= 0:
+                    break  # 已经读取足够的消息
+                
+                q_bytes = q.encode() if isinstance(q, str) else q
+                # 针对具体队列检查是否需要读取历史消息
+                if check_backlog.get(q, True):
+                    myid = lastid.get(q, "0-0")
+                else:
+                    myid = ">"
+                myid_bytes = myid.encode() if isinstance(myid, str) else myid
                 
                 try:
-                    # logger.debug(f'{group_name=} {consumer_name=} {block_time=}')
-                    consecutive_errors = 0
-                    # if check_backlog and messages:
-                    #     logger.debug(f'先消费之前的消息 {group_name=} ')
-                    # logger.debug(f'{check_backlog=} {messages=}')
-                    
-                    # 上报已投递的offset（用于积压监控）
-                    try:
-                        from jettask.utils.stream_backlog import report_delivered_offset
-                        # 对每个stream的消息上报offset
-                        for msg in messages:
-                            stream_name = msg[0]
-                            if isinstance(stream_name, bytes):
-                                stream_name = stream_name.decode('utf-8')
-                            # 提取队列名（去掉前缀）
-                            queue_name = stream_name.replace(f"{self.redis_prefix}:STREAM:", "")
-                            await report_delivered_offset(
-                                self.async_redis_client,
-                                self.redis_prefix,
-                                queue_name,
-                                group_name,
-                                [msg]
+                    # print(f'{myid_bytes=} {consumer_name=} {check_backlog=} {q_bytes=}')
+                    # 所有队列（包括优先级队列）都使用基础队列的 group_name
+                    # 从当前优先级队列读取（最多读取messages_needed个）
+                    q_messages = await self.async_binary_redis_client.xreadgroup(
+                        groupname=group_name,
+                        consumername=consumer_name,
+                        streams={q_bytes: myid_bytes},
+                        count=messages_needed,  # 只读取需要的数量
+                        block=100  # 非阻塞
+                    )
+                    # logger.info(f'{group_name=} {q_bytes=} {consumer_name=} {q_messages=}')
+                    if q_messages:
+                        # logger.info(f"Read messages from {q}: {len(q_messages[0][1]) if q_messages else 0} messages")
+                        # if check_backlog.get(q, True):
+                        #     print(f'先处理历史消息：{q_bytes=} {group_name=} {q_messages=}')
+                        # 记录从哪个队列读取的
+                        messages.extend(q_messages)
+                        messages_read = len(q_messages[0][1]) if q_messages else 0
+                        messages_needed -= messages_read
+                        
+                        # 如果高优先级队列还有消息，继续从该队列读取
+                        # 直到该队列空了或者达到prefetch限制
+                        if messages_read > 0 and messages_needed > 0:
+                            # 该队列可能还有更多消息，下次循环继续优先从这个队列读
+                            # 但现在先处理已读取的消息
+                            break  # 跳出for循环，处理已有消息
+                        
+                except Exception as e:
+                    if "NOGROUP" in str(e):
+                        # consumer group 不存在（可能是 Redis 被清空了），重新创建
+                        logger.warning(f"NOGROUP error for queue {q}, recreating consumer group...")
+                        try:
+                            # 为队列创建 consumer group（共享基础队列的 group_name）
+                            await self._ensure_consumer_group_and_record_info(
+                                q, task_name, consumer_name, base_group_name=group_name
                             )
-                    except Exception as e:
-                        # 监控失败不影响主流程
-                        logger.debug(f"Failed to report delivered offset: {e}")
-                    
-                    # 收集需要跳过的消息ID
-                    skip_message_ids = []
-                    
-                    # 用于记录每个队列的最大offset（批量更新）
-                    max_offsets_per_queue = {}
-                    
-                    for message in messages:
-                        # print(f'{message=}')
-                        # message[0]是stream名称，message[1]是消息列表
-                        stream_name = message[0]
+                            logger.info(f"Recreated consumer group for queue {q}")
+
+                            # 重新初始化这个队列的 lastid 和 check_backlog
+                            lastid[q] = "0"
+                            check_backlog[q] = True
+
+                            # 确保这个队列在 all_queues 中（可能因 Redis 清空而丢失）
+                            if q not in all_queues:
+                                all_queues.append(q)
+                                # 同时更新 priority_queues（如果是优先级队列）
+                                if q != prefixed_queue and q not in priority_queues:
+                                    priority_queues.append(q)
+                                    logger.info(f"Re-added queue {q} to all_queues after NOGROUP recovery")
+                        except Exception as recreate_error:
+                            logger.error(f"Failed to recreate consumer group for {q}: {recreate_error}")
+                    else:
+                        logger.debug(f"Error reading from queue {q}: {e}")
+                    continue
+
+            
+            try:
+                # logger.debug(f'{group_name=} {consumer_name=} {block_time=}')
+                consecutive_errors = 0
+                # if check_backlog and messages:
+                #     logger.debug(f'先消费之前的消息 {group_name=} ')
+                # logger.debug(f'{check_backlog=} {messages=}')
+                
+                # 上报已投递的offset（用于积压监控）
+                try:
+                    from jettask.utils.stream_backlog import report_delivered_offset
+                    # 对每个stream的消息上报offset
+                    for msg in messages:
+                        stream_name = msg[0]
                         if isinstance(stream_name, bytes):
                             stream_name = stream_name.decode('utf-8')
+                        # 提取队列名（去掉前缀）
+                        queue_name = stream_name.replace(f"{self.redis_prefix}:STREAM:", "")
+                        await report_delivered_offset(
+                            self.async_redis_client,
+                            self.redis_prefix,
+                            queue_name,
+                            group_name,
+                            [msg]
+                        )
+                except Exception as e:
+                    # 监控失败不影响主流程
+                    logger.debug(f"Failed to report delivered offset: {e}")
+                
+                # 收集需要跳过的消息ID
+                skip_message_ids = []
+                
+                # 用于记录每个队列的最大offset（批量更新）
+                max_offsets_per_queue = {}
+                
+                for message in messages:
+                    # print(f'{message=}')
+                    # message[0]是stream名称，message[1]是消息列表
+                    stream_name = message[0]
+                    if isinstance(stream_name, bytes):
+                        stream_name = stream_name.decode('utf-8')
+                    
+                    # 根据这个具体队列的消息数量，更新该队列的check_backlog状态
+                    if len(message[1]) == 0:
+                        # 这个队列没有历史消息了，下次读取最新消息
+                        check_backlog[stream_name] = False
+                    
+                    for event in message[1]:
+                        event_id = event[0]
+                        # 更新对应队列的lastid
+                        lastid[stream_name] = event_id
+                        # 将bytes类型的event_id转换为字符串
+                        if isinstance(event_id, bytes):
+                            event_id = event_id.decode('utf-8')
+                        event_data = event[1]
                         
-                        # 根据这个具体队列的消息数量，更新该队列的check_backlog状态
-                        if len(message[1]) == 0:
-                            # 这个队列没有历史消息了，下次读取最新消息
-                            check_backlog[stream_name] = False
+                        # 解析消息内容，决定是否处理
+                        should_process = True
                         
-                        for event in message[1]:
-                            event_id = event[0]
-                            # 更新对应队列的lastid
-                            lastid[stream_name] = event_id
-                            # 将bytes类型的event_id转换为字符串
-                            if isinstance(event_id, bytes):
-                                event_id = event_id.decode('utf-8')
-                            event_data = event[1]
-                            
-                            # 解析消息内容，决定是否处理
-                            should_process = True
-                            
-                            try:
-                                # 解析data字段中的消息
-                                if b'data' in event_data or 'data' in event_data:
-                                    data_field = event_data.get(b'data') or event_data.get('data')
-                                    
-                                    # 直接解析二进制数据，不需要解码
-                                    parsed_data = loads_str(data_field)
+                        try:
+                            # 解析data字段中的消息
+                            if b'data' in event_data or 'data' in event_data:
+                                data_field = event_data.get(b'data') or event_data.get('data')
+                                
+                                # 直接解析二进制数据，不需要解码
+                                parsed_data = loads_str(data_field)
+
+                                # 跳过延迟任务（延迟任务由延迟扫描器处理）
+                                # 但如果任务已到期，或者正在从 pending 恢复，则应该处理
+                                if parsed_data.get('is_delayed') == 1:
+                                    # 检查是否已到期
+                                    execute_at = parsed_data.get('execute_at')
+                                    current_time = time.time()
+
+                                    if execute_at and execute_at > current_time:
+                                        # 未到期，跳过（由Scanner处理）
+                                        should_process = False
+                                        continue
 
-                                    # 跳过延迟任务（延迟任务由延迟扫描器处理）
-                                    # 但如果任务已到期，或者正在从 pending 恢复，则应该处理
-                                    if parsed_data.get('is_delayed') == 1:
-                                        # 检查是否已到期
-                                        execute_at = parsed_data.get('execute_at')
-                                        current_time = time.time()
-
-                                        if execute_at and execute_at > current_time:
-                                            # 未到期，跳过（由Scanner处理）
-                                            should_process = False
-                                            continue
-
-                                        # 已到期或无execute_at字段，继续处理
-                                        # 这种情况可能是：
-                                        # 1. 延迟任务已到期，正在被执行
-                                        # 2. 从 pending 恢复的已到期任务
-                                        logger.debug(f"Processing expired delayed task {event_id}")
+                                    # 已到期或无execute_at字段，继续处理
+                                    # 这种情况可能是：
+                                    # 1. 延迟任务已到期，正在被执行
+                                    # 2. 从 pending 恢复的已到期任务
+                                    logger.debug(f"Processing expired delayed task {event_id}")
+                                
+                                # 每个task都有独立的consumer group
+                                # 检查消息是否指定了目标task（用于精确路由）
+                                target_tasks = parsed_data.get('_target_tasks', None)
+                                if target_tasks and task_name not in target_tasks:
+                                    # 这个消息指定了其他task处理
+                                    should_process = False
+                                
+                                if should_process:
+                                    # 添加task_name到数据中（用于执行器识别任务）
+                                    parsed_data['_task_name'] = task_name
                                     
-                                    # 每个task都有独立的consumer group
-                                    # 检查消息是否指定了目标task（用于精确路由）
-                                    target_tasks = parsed_data.get('_target_tasks', None)
-                                    if target_tasks and task_name not in target_tasks:
-                                        # 这个消息指定了其他task处理
-                                        should_process = False
+                                    # 提取offset字段（如果存在）
+                                    offset_field = event_data.get(b'offset') or event_data.get('offset')
+                                    message_offset = None
+                                    if offset_field:
+                                        # 将offset添加到parsed_data中
+                                        if isinstance(offset_field, bytes):
+                                            offset_field = offset_field.decode('utf-8')
+                                        parsed_data['offset'] = offset_field
+                                        try:
+                                            message_offset = int(offset_field)
+                                        except (ValueError, TypeError):
+                                            pass
                                     
-                                    if should_process:
-                                        # 添加task_name到数据中（用于执行器识别任务）
-                                        parsed_data['_task_name'] = task_name
-                                        
-                                        # 提取offset字段（如果存在）
-                                        offset_field = event_data.get(b'offset') or event_data.get('offset')
-                                        message_offset = None
-                                        if offset_field:
-                                            # 将offset添加到parsed_data中
-                                            if isinstance(offset_field, bytes):
-                                                offset_field = offset_field.decode('utf-8')
-                                            parsed_data['offset'] = offset_field
-                                            try:
-                                                message_offset = int(offset_field)
-                                            except (ValueError, TypeError):
-                                                pass
-                                        
-                                        # 更新event_data
-                                        event_data.clear()
-                                        for key, value in parsed_data.items():
-                                            event_data[key] = value
-                                        
-                                        # 收集每个队列的最大offset（不要每条消息都记录）
-                                        if message_offset is not None:
-                                            # 从stream_name提取实际的队列名
-                                            actual_queue_name = stream_name.replace(f"{self.redis_prefix}:QUEUE:", "")
-                                            # 更新该队列的最大offset
-                                            if actual_queue_name not in max_offsets_per_queue:
-                                                max_offsets_per_queue[actual_queue_name] = message_offset
-                                            else:
-                                                max_offsets_per_queue[actual_queue_name] = max(max_offsets_per_queue[actual_queue_name], message_offset)
-                                        
-                                        logger.debug(f"Task {task_name} will process message {event_id}")
-                                else:
-                                    # 没有data字段，跳过消息
-                                    should_process = False
-                            except Exception as e:
-                                logger.error(f"Task {task_name}: Error parsing message data: {e}")
-                            
-                            if should_process:
-                                # 处理消息 - 消息会被放入队列，由执行器处理并ACK
-                                # 使用消息体中的实际队列名（可能包含优先级）
-                                actual_queue = event_data.get('queue', queue)
-
-                                # 统一 group_name 架构：所有队列（包括优先级队列）使用同一个 consumer name
-                                # 不再需要为优先级队列添加后缀
-                                result = self._process_message_common(
-                                    event_id, event_data, actual_queue, task_event_queue,
-                                    is_async=True, consumer_name=consumer_name, group_name=group_name
-                                )
-                                if isinstance(result, tuple) and result[0] == 'async_put':
-                                    await self._async_put_task(task_event_queue, result[1])
-                                    logger.debug(f"Put task {event_id} into task_event_queue")
-                                # 注意：这里不ACK，由执行器在处理完成后ACK
+                                    # 更新event_data
+                                    event_data.clear()
+                                    for key, value in parsed_data.items():
+                                        event_data[key] = value
+                                    
+                                    # 收集每个队列的最大offset（不要每条消息都记录）
+                                    if message_offset is not None:
+                                        # 从stream_name提取实际的队列名
+                                        actual_queue_name = stream_name.replace(f"{self.redis_prefix}:QUEUE:", "")
+                                        # 更新该队列的最大offset
+                                        if actual_queue_name not in max_offsets_per_queue:
+                                            max_offsets_per_queue[actual_queue_name] = message_offset
+                                        else:
+                                            max_offsets_per_queue[actual_queue_name] = max(max_offsets_per_queue[actual_queue_name], message_offset)
+                                    
+                                    logger.debug(f"Task {task_name} will process message {event_id}")
                             else:
-                                # 不属于当前task的消息，收集起来批量ACK
-                                skip_message_ids.append(event_id)
-                            
-                    
-                    # 批量ACK不需要的消息（所有队列使用同一个 group_name）
-                    if skip_message_ids:
-                        group_name_bytes = group_name.encode() if isinstance(group_name, str) else group_name
-                        for q in all_queues:
-                            q_bytes = q.encode() if isinstance(q, str) else q
-                            try:
-                                await self.async_binary_redis_client.xack(q_bytes, group_name_bytes, *skip_message_ids)
-                            except:
-                                pass  # 忽略ACK错误
-                        logger.debug(f"Task {task_name} batch ACKed {len(skip_message_ids)} skipped messages")
-
-                    # 批量更新每个队列的最大已读取offset（所有队列使用同一个 group_name）
-                    if max_offsets_per_queue:
-                        for queue_name, max_offset in max_offsets_per_queue.items():
-                            asyncio.create_task(self._update_read_offset(queue_name, group_name, max_offset))
-                        logger.debug(f"Updated read offsets for {len(max_offsets_per_queue)} queues")
+                                # 没有data字段，跳过消息
+                                should_process = False
+                        except Exception as e:
+                            logger.error(f"Task {task_name}: Error parsing message data: {e}")
                         
-                except Exception as e:
-                    error_msg = str(e)
-                    # import traceback
-                    # traceback.print_exc()
-                    logger.error(f"Error in task listener {task_name}: {e}")
-                    
-                    # 特殊处理：如果是NOGROUP错误，尝试重新创建consumer group
-                    if "NOGROUP" in error_msg:
-                        logger.warning(f"Detected NOGROUP error for {task_name}, attempting to recreate consumer groups...")
+                        if should_process:
+                            # 处理消息 - 消息会被放入队列，由执行器处理并ACK
+                            # 使用消息体中的实际队列名（可能包含优先级）
+                            actual_queue = event_data.get('queue', queue)
+
+                            # 统一 group_name 架构：所有队列（包括优先级队列）使用同一个 consumer name
+                            # 不再需要为优先级队列添加后缀
+                            result = self._process_message_common(
+                                event_id, event_data, actual_queue, task_event_queue,
+                                is_async=True, consumer_name=consumer_name, group_name=group_name
+                            )
+                            if isinstance(result, tuple) and result[0] == 'async_put':
+                                await self._async_put_task(task_event_queue, result[1])
+                                logger.debug(f"Put task {event_id} into task_event_queue")
+                            # 注意：这里不ACK，由执行器在处理完成后ACK
+                        else:
+                            # 不属于当前task的消息，收集起来批量ACK
+                            skip_message_ids.append(event_id)
+                        
+                
+                # 批量ACK不需要的消息（所有队列使用同一个 group_name）
+                if skip_message_ids:
+                    group_name_bytes = group_name.encode() if isinstance(group_name, str) else group_name
+                    for q in all_queues:
+                        q_bytes = q.encode() if isinstance(q, str) else q
                         try:
-                            # 为所有队列创建consumer group并记录group_info（使用统一方法）
-                            for q in all_queues:
-                                await self._ensure_consumer_group_and_record_info(q, task_name, consumer_name)
-                            logger.info(f"Recreated consumer groups for {len(all_queues)} queues for task {task_name}")
-
-                            # 重新初始化所有队列的 lastid 和 check_backlog
-                            for q in all_queues:
-                                lastid[q] = "0"
-                                check_backlog[q] = True
-
-                            # 重新创建成功，重置错误计数器
-                            consecutive_errors = 0
-                            continue
-                        except Exception as create_error:
-                            logger.error(f"Failed to recreate consumer groups for {task_name}: {create_error}")
+                            await self.async_binary_redis_client.xack(q_bytes, group_name_bytes, *skip_message_ids)
+                        except:
+                            pass  # 忽略ACK错误
+                    logger.debug(f"Task {task_name} batch ACKed {len(skip_message_ids)} skipped messages")
+
+                # 批量更新每个队列的最大已读取offset（所有队列使用同一个 group_name）
+                if max_offsets_per_queue:
+                    for queue_name, max_offset in max_offsets_per_queue.items():
+                        asyncio.create_task(self._update_read_offset(queue_name, group_name, max_offset))
+                    logger.debug(f"Updated read offsets for {len(max_offsets_per_queue)} queues")
                     
-                    consecutive_errors += 1
-                    if consecutive_errors >= max_consecutive_errors:
-                        logger.error(f"Too many errors for task {task_name}, restarting...")
+            except Exception as e:
+                error_msg = str(e)
+                # import traceback
+                # traceback.print_exc()
+                logger.error(f"Error in task listener {task_name}: {e}")
+                
+                # 特殊处理：如果是NOGROUP错误，尝试重新创建consumer group
+                if "NOGROUP" in error_msg:
+                    logger.warning(f"Detected NOGROUP error for {task_name}, attempting to recreate consumer groups...")
+                    try:
+                        # 为所有队列创建consumer group并记录group_info（使用统一方法）
+                        for q in all_queues:
+                            await self._ensure_consumer_group_and_record_info(q, task_name, consumer_name)
+                        logger.info(f"Recreated consumer groups for {len(all_queues)} queues for task {task_name}")
+
+                        # 重新初始化所有队列的 lastid 和 check_backlog
+                        for q in all_queues:
+                            lastid[q] = "0"
+                            check_backlog[q] = True
+
+                        # 重新创建成功，重置错误计数器
                         consecutive_errors = 0
-                    await asyncio.sleep(min(consecutive_errors, 5))
-        
-        logger.debug(f"Starting event listeners for queues: {self.queues}")
+                        continue
+                    except Exception as create_error:
+                        logger.error(f"Failed to recreate consumer groups for {task_name}: {create_error}")
+                
+                consecutive_errors += 1
+                if consecutive_errors >= max_consecutive_errors:
+                    logger.error(f"Too many errors for task {task_name}, restarting...")
+                    consecutive_errors = 0
+                await asyncio.sleep(min(consecutive_errors, 5))
+
+
+    async def _listen_queues(self, queues: List[str], event_queue: dict, prefetch_multiplier: int):
+        """
+        为指定的队列启动监听任务
+
+        Args:
+            queues: 要监听的队列列表
+            event_queue: dict[str, asyncio.Queue] - 按task_name隔离的队列字典
+            prefetch_multiplier: 预取倍数
+
+        Returns:
+            List[asyncio.Task]: 创建的监听任务列表
+        """
         tasks = []
-        
+
         if not (self.app and hasattr(self.app, '_tasks_by_queue')):
             raise RuntimeError("No app or tasks registered, cannot start listeners")
-        
-        # 为每个队列注册延迟任务回调
-        async def handle_expired_tasks(queue: str, tasks: list):
-            """处理到期的延迟任务"""
-            if tasks:
-                async with self._delayed_tasks_locks[queue]:
-                    self._delayed_tasks_lists[queue].extend(tasks)
 
-        for queue in self.queues:
+        # 为每个队列初始化延迟任务列表（如果还没有）
+        for queue in queues:
+            if queue not in self._delayed_tasks_lists:
+                self._delayed_tasks_lists[queue] = []
+                self._delayed_tasks_locks[queue] = asyncio.Lock()
+
+        # 为每个队列注册延迟扫描器回调
+        for queue in queues:
             # 创建队列专用的回调函数
             import functools
-            callback = functools.partial(handle_expired_tasks, queue)
+            callback = functools.partial(self.handle_expired_tasks, queue)
             self.delayed_scanner.register_callback(queue, callback)
 
-        # 启动延迟消息扫描器
-        await self.delayed_scanner.start(self.queues)
-        logger.info(f"Delayed message scanner started for queues: {self.queues}")
-        
+        # 添加队列到延迟消息扫描器
+        await self.delayed_scanner.add_queues(queues)
+        logger.info(f"Added queues to delayed message scanner: {queues}")
+
         # 为每个队列启动离线worker处理器（带自动重启）
         # 包括优先级队列
-        all_recovery_queues = set(self.queues)
-        for base_queue in self.queues:
+        all_recovery_queues = set(queues)
+        for base_queue in queues:
             # 扫描优先级队列
             priority_queues = await self.scan_priority_queues(base_queue)
             for pq in priority_queues:
                 if pq != base_queue:  # 不重复添加基础队列
                     all_recovery_queues.add(pq)
-        
-        # ✅ 在启动离线worker处理器之前，先触发一次"自我恢复"
-        # 这是为了处理"复用worker ID"的场景：
-        # - Worker复用离线worker ID后，会立即变为在线状态
-        # - 但此时该worker之前的pending消息还未恢复
-        # - 周期性扫描只查找is_alive=false的worker，会漏掉刚复用的worker
-        # - 因此需要在启动时主动恢复"当前worker"的pending消息
-        # logger.info("[Recovery] Performing initial self-recovery check on startup...")
-        # try:
-        #     await self._perform_self_recovery(all_recovery_queues, event_queue)
-        # except Exception as e:
-        #     logger.error(f"Error during initial self-recovery: {e}", exc_info=True)
 
         # 为所有队列（包括优先级队列）启动离线worker处理器
         for queue in all_recovery_queues:
             logger.debug(f"Starting offline worker processor for queue: {queue}")
             offline_processor_task = asyncio.create_task(
-                self._start_offline_worker_processor_with_restart(queue)  # 移除 event_queue 参数
+                self._start_offline_worker_processor_with_restart(queue)
             )
             tasks.append(offline_processor_task)
             self._background_tasks.append(offline_processor_task)
-        
-        # # 为每个task创建独立的listener
-        for queue in self.queues:
-            task_names = self.app._tasks_by_queue.get(queue, [])
+
+        # 为每个task创建独立的listener
+        for queue in queues:
+            # 使用工具方法查找匹配的任务
+            from jettask.utils.queue_matcher import find_matching_tasks
+
+            task_names = find_matching_tasks(queue, self.app._tasks_by_queue, self.wildcard_mode)
+
+            if task_names and self.wildcard_mode:
+                # 记录通配符匹配日志（仅在通配符模式下且找到任务时）
+                if queue not in self.app._tasks_by_queue:
+                    logger.info(f"队列 '{queue}' 通过通配符匹配找到任务: {task_names}")
+
             if not task_names:
-                raise RuntimeError(f"No tasks registered for queue '{queue}'. Cannot start worker without tasks.")
-            
+                # 在通配符模式下，如果队列没有任务也不报错（可能是动态发现的队列）
+                if not self.wildcard_mode:
+                    raise RuntimeError(f"No tasks registered for queue '{queue}'. Cannot start worker without tasks.")
+                else:
+                    logger.debug(f"No tasks registered for queue '{queue}', skipping...")
+                    continue
+
             for task_name in task_names:
-                logger.debug(f"Starting listener for task: {task_name} on queue: {queue}")
-                task = asyncio.create_task(listen_event_by_task(queue, task_name))
+                logger.info(f"Starting listener for task: {task_name} on queue: {queue}")
+                task = asyncio.create_task(self.listen_event_by_task(event_queue, queue, task_name, prefetch_multiplier))
                 tasks.append(task)
                 self._background_tasks.append(task)
-        
+
+        return tasks
+
+    async def _dynamic_queue_discovery(self, wildcard_patterns: List[str], event_queue: dict, prefetch_multiplier: int, interval: float = 5.0):
+        """
+        动态队列发现后台任务
+
+        Args:
+            wildcard_patterns: 通配符模式列表
+            event_queue: 任务事件队列字典
+            prefetch_multiplier: 预取倍数
+            interval: 检查间隔（秒）
+        """
+        logger.info(f"启动动态队列发现任务，通配符模式: {wildcard_patterns}, 检查间隔: {interval}秒")
+
+        while not self._stop_reading:
+            try:
+                # 调用队列发现方法，返回新发现的队列
+                new_queues = await self.discover_and_update_queues(wildcard_patterns)
+
+                if new_queues:
+                    # logger.info(f"发现新队列: {new_queues}")
+                    # 为新队列启动监听
+                    new_tasks = await self._listen_queues(new_queues, event_queue, prefetch_multiplier)
+                    # logger.info(f"已为 {len(new_queues)} 个新队列启动监听，创建了 {len(new_tasks)} 个任务")
+
+                # 等待下一次检查
+                await asyncio.sleep(interval)
+
+            except asyncio.CancelledError:
+                logger.info("动态队列发现任务已取消")
+                break
+            except Exception as e:
+                logger.error(f"动态队列发现出错: {e}", exc_info=True)
+                await asyncio.sleep(interval)
+
+    async def listening_event(self, event_queue: dict, prefetch_multiplier: int = 1):
+        """监听事件 - 为每个task创建独立的consumer group
+
+        Args:
+            event_queue: dict[str, asyncio.Queue] - 按task_name隔离的队列字典
+            prefetch_multiplier: 预取倍数
+        """
+        # 验证参数类型
+        if not isinstance(event_queue, dict):
+            raise TypeError(f"event_queue must be a dict[str, asyncio.Queue], got {type(event_queue)}")
+
+        # 保存 event_queue 字典的引用，供事件驱动的恢复使用
+        self._event_queue_dict = event_queue
+
+        logger.info(f"Using task-isolated event queue mode for tasks: {list(event_queue.keys())}")
+
+        # 保存所有创建的任务，以便清理时能够取消它们
+        self._background_tasks = []
+
+        logger.info(f"静态队列: {self.queues}, 通配符模式: {self.wildcard_patterns}")
+
+        # 创建延迟任务字典
+        self._delayed_tasks_lists = {}
+        self._delayed_tasks_locks = {}
+
+        # 启动延迟消息扫描器（先用静态队列启动，后续动态添加）
+        await self.delayed_scanner.start(self.queues)
+        logger.info(f"Delayed message scanner started for static queues: {self.queues}")
+
+        tasks = []
+
+        # 1. 先为静态队列（不包含通配符的队列）启动监听
+        if self.queues:
+            static_tasks = await self._listen_queues(self.queues, event_queue, prefetch_multiplier)
+            tasks.extend(static_tasks)
+            logger.info(f"已为 {len(self.queues)} 个静态队列启动监听")
+
+        # 2. 如果有通配符模式，启动动态队列发现任务
+        if self.wildcard_patterns:
+            discovery_task = asyncio.create_task(
+                self._dynamic_queue_discovery(self.wildcard_patterns, event_queue, prefetch_multiplier, interval=5.0)
+            )
+            tasks.append(discovery_task)
+            self._background_tasks.append(discovery_task)
+            logger.info(f"已启动动态队列发现任务，通配符模式: {self.wildcard_patterns}")
+
         try:
             # 等待所有任务
             await asyncio.gather(*tasks)
@@ -1987,9 +2233,6 @@ class EventPool(object):
                     logger.debug("Some background tasks did not complete in time")
             raise
     
-    # 注意：延迟任务扫描逻辑已迁移到 DelayedMessageScanner 独立模块
-    # 旧的 _scan_and_load_delayed_tasks_to_list 和 _scan_and_load_delayed_tasks 方法已删除
-    
     async def _claim_delayed_tasks(self, queue: str, event_queue: asyncio.Queue, prefetch_multiplier: int):
         """处理延迟队列中的到期任务"""
         try: