funboost 49.1__tar.gz → 49.3__tar.gz

{funboost-49.1/funboost.egg-info → funboost-49.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 49.1
+Version: 49.3
 Summary: pip install funboost，python全功能分布式函数调度框架,funboost的功能是全面性重量级，用户能想得到的功能99%全都有;funboost的使用方式是轻量级，只有@boost一行代码需要写。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，funboost web manager 方便查看和管理消费函数；99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
 Home-page: https://github.com/ydf0509/funboost
 Author: bfzs
@@ -23,6 +23,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
@@ -72,8 +73,10 @@ Broker。funboost源码高扩展性的设计，造成“万物皆可为Broker”
 框架对代码没有入侵,可以加到任意已有项目而对项目python文件目录结构0要求,
 不像 celery django scrapy 这样的框架,要从一开始就开始规划好项目目录结构,如果不想用框架了,
 或者想改变使用其他框架框架,那么已经所写的代码组织形式就几乎成了废物,需要大改特改. 
-但是funboost完全不会这样,加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
+但是funboost完全不会这样,就算是加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
 所以用户可以对任意项目,任意时候,引入使用funboost或者去掉使用funboost,代码组织形式不需要发生变化.
+（即使不想用funboost了，也不需要亲自去掉@boost装饰器，因为函数有@boost装饰器对函数自身的直接调用运行没有任何影响，
+用户照样可以直接例如 fun(x,y)是直接运行函数 ， fun.push(x,y) 才是发送到消息队列）
 
 通过funboost web manager 管理系统，支持全面 查看 监控 管理 funboost的任务消费。
 </pre>
@@ -485,26 +488,32 @@ if __name__ == "__main__":
 
 
 
-## 1.3.2 funboost丝滑连续启动多个函数消费
+## 1.3.2 funboost集中演示一个功能更多的综合例子
 
 ```python
 
+
 """
-此代码
-1.演示支持多个函数消费队列的无阻塞启动（consume不会阻塞主线程）
-2.演示支持在一个消费函数内部向任意队列发布新任务，实现多级任务链
-代码结构清晰，扩展性极强
+一个展示更全面 funboost 用法的例子
+包含了
+1.继承BoosterParams，为了每个装饰器少写入参
+2.rpc获取结果
+3.连续丝滑启动多个消费函数
+4.定时任务
 """
-from funboost import boost, BrokerEnum,BoosterParams,ctrl_c_recv,ConcurrentModeEnum
+from funboost import boost, BrokerEnum,BoosterParams,ctrl_c_recv,ConcurrentModeEnum,ApsJobAdder
 import time
 
 class MyBoosterParams(BoosterParams):  # 自定义的参数类，继承BoosterParams，用于减少每个消费函数装饰器的重复相同入参个数
-    broker_kind: str = BrokerEnum.MEMORY_QUEUE
+    broker_kind: str = BrokerEnum.REDIS_ACK_ABLE
     max_retry_times: int = 3
     concurrent_mode: str = ConcurrentModeEnum.THREADING 
 
     
-@boost(MyBoosterParams(queue_name='s1_queue', qps=1, ))
+@boost(MyBoosterParams(queue_name='s1_queue', qps=1, 
+                    #    do_task_filtering=True, # 可开启任务过滤，防止重复入参消费。
+                       is_using_rpc_mode=True, # 开启rpc模式，支持rpc获取结果
+                       ))
 def step1(a:int,b:int):
     print(f'a={a},b={b}')
     time.sleep(0.7)
@@ -513,20 +522,75 @@ def step1(a:int,b:int):
     return a+b
 
 
-@boost(MyBoosterParams(queue_name='s2_queue', qps=3, ))
-def step2(c:int,d:int,e:int):
+@boost(MyBoosterParams(queue_name='s2_queue', qps=3, 
+                      max_retry_times=5，# 可以在此覆盖MyBoosterParams中的默认值，例如为step2单独设置最大重试次数为5
+)) 
+def step2(c:int,d:int,e:int=666):
     time.sleep(3)
     print(f'c={c},d={d},e={e}')
     return c* d * e
 
 
 if __name__ == '__main__':
-    for i in range(100):
-        step1.push(i,i*2) # 向 step1函数的队列发送消息。
+    step1.clear() # 清空队列
+    step2.clear() # 清空队列
+
     step1.consume() # 调用.consume是非阻塞的启动消费，是在单独的子线程中循环拉取消息的。 
     # 有的人还担心阻塞而手动使用 threading.Thread(target=step1.consume).start() 来启动消费，这是完全多此一举的错误写法。
-    step2.consume() # 所以可以连续无阻塞丝滑的启动多个函数消费。
-    ctrl_c_recv()
+    step2.consume() # 所以可以在当前主线程连续无阻塞丝滑的启动多个函数消费。
+    step2.multi_process_consume(3) # 这是多进程叠加了多线程消费，另外开启了3个进程，叠加了默认的线程并发。
+
+    async_result = step1.push(100,b=200)
+    print('step1的rpc结果是：',async_result.result)  # rpc阻塞等待消step1的费结果返回
+
+    for i in range(100):
+        step1.push(i,i*2) # 向 step1函数的队列发送消息,入参和手动调用函数那样很相似。
+        step1.publish ({'a':i,'b':i*2},task_id=f'task_{i}') # publish 第一个入参是字典，比push能传递更多funboost的辅助参数，类似celery的apply_async和delay的关系。一个简单，一个复杂但强大。
+    
+    
+
+    """
+    1.funboost 使用 ApsJobAdder.add_push_job来添加定时任务，不是add_job。
+    2.funboost是轻度封装的知名apscheduler框架，所以定时任务的语法和apscheduler是一样的，没有自己发明语法和入参
+    用户需要苦学apscheduler教程，一切定时都是要学apscheduler知识，定时和funboost知识关系很小。
+    3.funboost的定时任务目的是定时推送消息到消息队列中，而不是定时直接在当前程序中执行某个消费函数。
+
+    下面是三种方式添加定时任务，这些定时方式都是知名apscheduler包的定时方式，和funboost没关系。
+    """
+    # 方式1：指定日期执行一次
+    ApsJobAdder(step2, 
+               job_store_kind='redis', # 使用reids作为 apscheduler的 jobstrores
+               is_auto_start=True,   # 添加任务，并同时顺便启动了定时器 执行了apscheduler对象.start()
+    ).add_push_job(
+        trigger='date',
+        run_date='2025-06-30 16:25:40',
+        args=(7, 8,9),
+        id='date_job1',
+        replace_existing=True,
+    )
+
+    # 方式2：固定间隔执行
+    ApsJobAdder(step2, job_store_kind='redis').add_push_job(
+        trigger='interval',
+        seconds=30,
+        args=(4, 6,10),
+        id='interval_job1',
+        replace_existing=True,
+    )
+
+    # 方式3：使用cron表达式定时执行
+    ApsJobAdder(step2, job_store_kind='redis').add_push_job(
+        trigger='cron',
+        day_of_week='*',
+        hour=23,
+        minute=49,
+        second=50,
+        kwargs={"c": 50, "d": 60,"e":70},
+        replace_existing=True,
+        id='cron_job1')
+    
+    ctrl_c_recv()  # 用于阻塞代码，阻止主线程退出，使主线程永久运行。  相当于 你在代码最末尾，加了个 while 1:time.sleep(10)，使主线程永不结束。apscheduler background定时器守护线程需要这样保持定时器不退出。
+
 
 ```
 
@@ -594,14 +658,17 @@ python比其他语言更需要分布式函数调度框架来执行函数，有
 
 ## 1.6 funboost支持支持celery框架整体作为funboost的broker (2023.4新增)
 ```
-见11.1章节代码例子，celery框架整体作为funboost的broker，funboost的发布和消费将只作为极简api，核心的消费调度和发布和定时功能，都是由celery框架来完成，funboost框架的发布和调度代码不实际起作用。
+见11.1章节代码例子，celery框架整体作为funboost的broker，funboost的发布和消费将只作为极简api，
+核心的消费调度和发布和定时功能，都是由celery框架来完成，funboost框架的发布和调度代码不实际起作用。
 用户操作funboost的api，语法和使用其他消息队列中间件类型一样，funboost自动化操作celery。
 
 用户无需操作celery本身，无需敲击celery难记的命令行启动消费、定时、flower;
 用户无需小心翼翼纠结亲自使用celery时候怎么规划目录结构 文件夹命名 需要怎么在配置写include 写task_routes，
-完全不存在需要固定的celery目录结构，不需要手动配置懵逼的任务路由，不需要配置每个函数怎么使用不同的队列名字，funboost自动搞定这些。
+完全不存在需要固定的celery目录结构，不需要手动配置懵逼的任务路由，
+不需要配置每个函数怎么使用不同的队列名字，funboost自动搞定这些。
 
-用户只需要使用简单的funboost语法就能操控celery框架了。funboost使用celery作为broker_kind,远远的暴击亲自使用无法ide下代码补全的celery框架的语法。
+用户只需要使用简单的funboost语法就能操控celery框架了。funboost使用celery作为broker_kind,
+远远的暴击亲自使用无法ide下代码补全的celery框架的语法。
 ```
 
 ```

{funboost-49.1 → funboost-49.3}/README.md

@@ -1,9 +1,3 @@
----
-noteId: "67d3a8f045e411f0ab0bf59d9f569ed4"
-tags: []
-
----
-
 
 
 # 1.python万能分布式函数调度框架简funboost简介
@@ -45,8 +39,10 @@ Broker。funboost源码高扩展性的设计，造成“万物皆可为Broker”
 框架对代码没有入侵,可以加到任意已有项目而对项目python文件目录结构0要求,
 不像 celery django scrapy 这样的框架,要从一开始就开始规划好项目目录结构,如果不想用框架了,
 或者想改变使用其他框架框架,那么已经所写的代码组织形式就几乎成了废物,需要大改特改. 
-但是funboost完全不会这样,加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
+但是funboost完全不会这样,就算是加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
 所以用户可以对任意项目,任意时候,引入使用funboost或者去掉使用funboost,代码组织形式不需要发生变化.
+（即使不想用funboost了，也不需要亲自去掉@boost装饰器，因为函数有@boost装饰器对函数自身的直接调用运行没有任何影响，
+用户照样可以直接例如 fun(x,y)是直接运行函数 ， fun.push(x,y) 才是发送到消息队列）
 
 通过funboost web manager 管理系统，支持全面 查看 监控 管理 funboost的任务消费。
 </pre>
@@ -458,26 +454,32 @@ if __name__ == "__main__":
 
 
 
-## 1.3.2 funboost丝滑连续启动多个函数消费
+## 1.3.2 funboost集中演示一个功能更多的综合例子
 
 ```python
 
+
 """
-此代码
-1.演示支持多个函数消费队列的无阻塞启动（consume不会阻塞主线程）
-2.演示支持在一个消费函数内部向任意队列发布新任务，实现多级任务链
-代码结构清晰，扩展性极强
+一个展示更全面 funboost 用法的例子
+包含了
+1.继承BoosterParams，为了每个装饰器少写入参
+2.rpc获取结果
+3.连续丝滑启动多个消费函数
+4.定时任务
 """
-from funboost import boost, BrokerEnum,BoosterParams,ctrl_c_recv,ConcurrentModeEnum
+from funboost import boost, BrokerEnum,BoosterParams,ctrl_c_recv,ConcurrentModeEnum,ApsJobAdder
 import time
 
 class MyBoosterParams(BoosterParams):  # 自定义的参数类，继承BoosterParams，用于减少每个消费函数装饰器的重复相同入参个数
-    broker_kind: str = BrokerEnum.MEMORY_QUEUE
+    broker_kind: str = BrokerEnum.REDIS_ACK_ABLE
     max_retry_times: int = 3
     concurrent_mode: str = ConcurrentModeEnum.THREADING 
 
     
-@boost(MyBoosterParams(queue_name='s1_queue', qps=1, ))
+@boost(MyBoosterParams(queue_name='s1_queue', qps=1, 
+                    #    do_task_filtering=True, # 可开启任务过滤，防止重复入参消费。
+                       is_using_rpc_mode=True, # 开启rpc模式，支持rpc获取结果
+                       ))
 def step1(a:int,b:int):
     print(f'a={a},b={b}')
     time.sleep(0.7)
@@ -486,20 +488,75 @@ def step1(a:int,b:int):
     return a+b
 
 
-@boost(MyBoosterParams(queue_name='s2_queue', qps=3, ))
-def step2(c:int,d:int,e:int):
+@boost(MyBoosterParams(queue_name='s2_queue', qps=3, 
+                      max_retry_times=5，# 可以在此覆盖MyBoosterParams中的默认值，例如为step2单独设置最大重试次数为5
+)) 
+def step2(c:int,d:int,e:int=666):
     time.sleep(3)
     print(f'c={c},d={d},e={e}')
     return c* d * e
 
 
 if __name__ == '__main__':
-    for i in range(100):
-        step1.push(i,i*2) # 向 step1函数的队列发送消息。
+    step1.clear() # 清空队列
+    step2.clear() # 清空队列
+
     step1.consume() # 调用.consume是非阻塞的启动消费，是在单独的子线程中循环拉取消息的。 
     # 有的人还担心阻塞而手动使用 threading.Thread(target=step1.consume).start() 来启动消费，这是完全多此一举的错误写法。
-    step2.consume() # 所以可以连续无阻塞丝滑的启动多个函数消费。
-    ctrl_c_recv()
+    step2.consume() # 所以可以在当前主线程连续无阻塞丝滑的启动多个函数消费。
+    step2.multi_process_consume(3) # 这是多进程叠加了多线程消费，另外开启了3个进程，叠加了默认的线程并发。
+
+    async_result = step1.push(100,b=200)
+    print('step1的rpc结果是：',async_result.result)  # rpc阻塞等待消step1的费结果返回
+
+    for i in range(100):
+        step1.push(i,i*2) # 向 step1函数的队列发送消息,入参和手动调用函数那样很相似。
+        step1.publish ({'a':i,'b':i*2},task_id=f'task_{i}') # publish 第一个入参是字典，比push能传递更多funboost的辅助参数，类似celery的apply_async和delay的关系。一个简单，一个复杂但强大。
+    
+    
+
+    """
+    1.funboost 使用 ApsJobAdder.add_push_job来添加定时任务，不是add_job。
+    2.funboost是轻度封装的知名apscheduler框架，所以定时任务的语法和apscheduler是一样的，没有自己发明语法和入参
+    用户需要苦学apscheduler教程，一切定时都是要学apscheduler知识，定时和funboost知识关系很小。
+    3.funboost的定时任务目的是定时推送消息到消息队列中，而不是定时直接在当前程序中执行某个消费函数。
+
+    下面是三种方式添加定时任务，这些定时方式都是知名apscheduler包的定时方式，和funboost没关系。
+    """
+    # 方式1：指定日期执行一次
+    ApsJobAdder(step2, 
+               job_store_kind='redis', # 使用reids作为 apscheduler的 jobstrores
+               is_auto_start=True,   # 添加任务，并同时顺便启动了定时器 执行了apscheduler对象.start()
+    ).add_push_job(
+        trigger='date',
+        run_date='2025-06-30 16:25:40',
+        args=(7, 8,9),
+        id='date_job1',
+        replace_existing=True,
+    )
+
+    # 方式2：固定间隔执行
+    ApsJobAdder(step2, job_store_kind='redis').add_push_job(
+        trigger='interval',
+        seconds=30,
+        args=(4, 6,10),
+        id='interval_job1',
+        replace_existing=True,
+    )
+
+    # 方式3：使用cron表达式定时执行
+    ApsJobAdder(step2, job_store_kind='redis').add_push_job(
+        trigger='cron',
+        day_of_week='*',
+        hour=23,
+        minute=49,
+        second=50,
+        kwargs={"c": 50, "d": 60,"e":70},
+        replace_existing=True,
+        id='cron_job1')
+    
+    ctrl_c_recv()  # 用于阻塞代码，阻止主线程退出，使主线程永久运行。  相当于 你在代码最末尾，加了个 while 1:time.sleep(10)，使主线程永不结束。apscheduler background定时器守护线程需要这样保持定时器不退出。
+
 
 ```
 
@@ -567,14 +624,17 @@ python比其他语言更需要分布式函数调度框架来执行函数，有
 
 ## 1.6 funboost支持支持celery框架整体作为funboost的broker (2023.4新增)
 ```
-见11.1章节代码例子，celery框架整体作为funboost的broker，funboost的发布和消费将只作为极简api，核心的消费调度和发布和定时功能，都是由celery框架来完成，funboost框架的发布和调度代码不实际起作用。
+见11.1章节代码例子，celery框架整体作为funboost的broker，funboost的发布和消费将只作为极简api，
+核心的消费调度和发布和定时功能，都是由celery框架来完成，funboost框架的发布和调度代码不实际起作用。
 用户操作funboost的api，语法和使用其他消息队列中间件类型一样，funboost自动化操作celery。
 
 用户无需操作celery本身，无需敲击celery难记的命令行启动消费、定时、flower;
 用户无需小心翼翼纠结亲自使用celery时候怎么规划目录结构 文件夹命名 需要怎么在配置写include 写task_routes，
-完全不存在需要固定的celery目录结构，不需要手动配置懵逼的任务路由，不需要配置每个函数怎么使用不同的队列名字，funboost自动搞定这些。
+完全不存在需要固定的celery目录结构，不需要手动配置懵逼的任务路由，
+不需要配置每个函数怎么使用不同的队列名字，funboost自动搞定这些。
 
-用户只需要使用简单的funboost语法就能操控celery框架了。funboost使用celery作为broker_kind,远远的暴击亲自使用无法ide下代码补全的celery框架的语法。
+用户只需要使用简单的funboost语法就能操控celery框架了。funboost使用celery作为broker_kind,
+远远的暴击亲自使用无法ide下代码补全的celery框架的语法。
 ```
 
 ```

{funboost-49.1 → funboost-49.3}/funboost/__init__.py

@@ -13,7 +13,7 @@ set_frame_config这个模块的 use_config_form_funboost_config_module() 是核
 这段注释说明和使用的用户无关,只和框架开发人员有关.
 '''
 
-__version__ = "49.1"
+__version__ = "49.3"
 
 from funboost.set_frame_config import show_frame_config
 

{funboost-49.1 → funboost-49.3}/funboost/concurrent_pool/async_helper.py

@@ -9,6 +9,21 @@ async_executor_default = ThreadPoolExecutorShrinkAble(500)
 # async_executor_default = FlexibleThreadPool(50)  # 这个不支持future特性
 
 
+def get_or_create_event_loop():
+    try:
+        # Python 3.7+
+        return asyncio.get_running_loop()
+    except RuntimeError:
+        # 没有正在运行的 loop
+        try:
+            # Python 3.6~3.9：get_event_loop 会自动创建
+            return asyncio.get_event_loop()
+        except RuntimeError:
+            # Python 3.10+：get_event_loop 不再自动创建
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            return loop
+        
 async def simple_run_in_executor(f, *args, async_executor: Executor = None, async_loop=None, **kwargs):
     """
     一个很强的函数，使任意同步同步函数f，转化成asyncio异步api语法，
@@ -31,13 +46,17 @@ async def simple_run_in_executor(f, *args, async_executor: Executor = None, asyn
     :param kwargs:f函数的关键字方式入参
     :return:
     """
-    loopx = async_loop or asyncio.get_event_loop()
+    loopx = async_loop or get_or_create_event_loop()
     async_executorx = async_executor or async_executor_default
     # print(id(loopx))
     result = await loopx.run_in_executor(async_executorx, partial(f, *args, **kwargs))
     return result
 
 
+
+
+
+
 if __name__ == '__main__':
     import time
     import requests

{funboost-49.1 → funboost-49.3}/funboost/concurrent_pool/async_pool_executor.py

@@ -48,7 +48,7 @@ if sys.platform == "darwin":  # mac 上会出错
       import selectors
       selectors.DefaultSelector = selectors.PollSelector
 
-class AsyncPoolExecutorLtPy310(FunboostFileLoggerMixin,FunboostBaseConcurrentPool):
+class AsyncPoolExecutor(FunboostFileLoggerMixin,FunboostBaseConcurrentPool):
     """
     使api和线程池一样，最好的性能做法是submit也弄成 async def，生产和消费在同一个线程同一个loop一起运行，但会对调用链路的兼容性产生破坏，从而调用方式不兼容线程池。
     """
@@ -62,28 +62,31 @@ class AsyncPoolExecutorLtPy310(FunboostFileLoggerMixin,FunboostBaseConcurrentPoo
         self._size = size
         self.loop = loop or asyncio.new_event_loop()
         asyncio.set_event_loop(self.loop)
-        self._sem = asyncio.Semaphore(self._size, loop=self.loop)
-        self._queue = asyncio.Queue(maxsize=size, loop=self.loop)
-        self._lock = threading.Lock()
-        t = Thread(target=self._start_loop_in_new_thread, daemon=True)
+        self._diff_init()
+        # self._lock = threading.Lock()
+        t = Thread(target=self._start_loop_in_new_thread, daemon=False)
         # t.setDaemon(True)  # 设置守护线程是为了有机会触发atexit，使程序自动结束，不用手动调用shutdown
         t.start()
-        self._can_be_closed_flag = False
-        atexit.register(self.shutdown)
-
-        self._event = threading.Event()
-        # print(self._event.is_set())
-        self._event.set()
-
-    def submit000(self, func, *args, **kwargs):
-        # 这个性能比下面的采用 run_coroutine_threadsafe + result返回快了3倍多。
-        with self._lock:
-            while 1:
-                if not self._queue.full():
-                    self.loop.call_soon_threadsafe(self._queue.put_nowait, (func, args, kwargs))
-                    break
-                else:
-                    time.sleep(0.01)
+     
+
+    # def submit000(self, func, *args, **kwargs):
+    #     # 这个性能比下面的采用 run_coroutine_threadsafe + result返回快了3倍多。
+    #     with self._lock:
+    #         while 1:
+    #             if not self._queue.full():
+    #                 self.loop.call_soon_threadsafe(self._queue.put_nowait, (func, args, kwargs))
+    #                 break
+    #             else:
+    #                 time.sleep(0.01)
+
+    def _diff_init(self):
+        if sys.version_info.minor < 10:
+            # self._sem = asyncio.Semaphore(self._size, loop=self.loop)
+            self._queue = asyncio.Queue(maxsize=self._size, loop=self.loop)
+        else:
+            # self._sem = asyncio.Semaphore(self._size) # python3.10后，很多类和方法都删除了loop传参
+            self._queue = asyncio.Queue(maxsize=self._size)
+
 
     def submit(self, func, *args, **kwargs):
         future = asyncio.run_coroutine_threadsafe(self._produce(func, *args, **kwargs), self.loop)  # 这个 run_coroutine_threadsafe 方法也有缺点，消耗的性能巨大。
@@ -102,7 +105,7 @@ class AsyncPoolExecutorLtPy310(FunboostFileLoggerMixin,FunboostBaseConcurrentPoo
             try:
                 await func(*args, **kwargs)
             except BaseException as e:
-                traceback.print_exc()
+                self.logger.exception(f'func:{func}, args:{args}, kwargs:{kwargs} exc_type:{type(e)}  traceback_exc:{traceback.format_exc()}')
             # self._queue.task_done()
 
     async def __run(self):
@@ -114,54 +117,33 @@ class AsyncPoolExecutorLtPy310(FunboostFileLoggerMixin,FunboostBaseConcurrentPoo
         # self._loop.run_forever()
 
         # asyncio.set_event_loop(self.loop)
-        self.loop.run_until_complete(asyncio.wait([self._consume() for _ in range(self._size)], loop=self.loop))
-        self._can_be_closed_flag = True
+        # self.loop.run_until_complete(asyncio.wait([self._consume() for _ in range(self._size)], loop=self.loop))
+        # self._can_be_closed_flag = True
+        [self.loop.create_task(self._consume()) for _ in range(self._size)]
+        try:
+            self.loop.run_forever()
+        except Exception as e:
+            self.logger.warning(f'{e}')   # 如果多个线程使用一个loop，不能重复启动loop，否则会报错。
 
-    def shutdown(self):
-        if self.loop.is_running():  # 这个可能是atregster触发，也可能是用户手动调用，需要判断一下，不能关闭两次。
-            for i in range(self._size):
-                self.submit(f'stop{i}', )
-            while not self._can_be_closed_flag:
-                time.sleep(0.1)
-            self.loop.stop()
-            self.loop.close()
-            print('关闭循环')
 
 
+    # def shutdown(self):
+    #     if self.loop.is_running():  # 这个可能是atregster触发，也可能是用户手动调用，需要判断一下，不能关闭两次。
+    #         for i in range(self._size):
+    #             self.submit(f'stop{i}', )
+    #         while not self._can_be_closed_flag:
+    #             time.sleep(0.1)
+    #         self.loop.stop()
+    #         self.loop.close()
+    #         print('关闭循环')
+
 
-class AsyncPoolExecutorGtPy310(AsyncPoolExecutorLtPy310):
-    # noinspection PyMissingConstructor
-    def __init__(self, size, loop=None):
-        """
 
-        :param size: 同时并发运行的协程任务数量。
-        :param loop:
-        """
-        self._size = size
-        self.loop = loop or asyncio.new_event_loop()
-        self._sem = asyncio.Semaphore(self._size, )
-        self._queue = asyncio.Queue(maxsize=size, )
-        self._lock = threading.Lock()
-        t = Thread(target=self._start_loop_in_new_thread, daemon=True)
-        # t.setDaemon(True)  # 设置守护线程是为了有机会触发atexit，使程序自动结束，不用手动调用shutdown
-        t.start()
-        self._can_be_closed_flag = False
-        atexit.register(self.shutdown)
 
-        self._event = threading.Event()
-        # print(self._event.is_set())
-        self._event.set()
 
-    def _start_loop_in_new_thread(self, ):
-        # self._loop.run_until_complete(self.__run())  # 这种也可以。
-        # self._loop.run_forever()
 
-        # asyncio.set_event_loop(self.loop)
-        self.loop.run_until_complete(asyncio.wait([self.loop.create_task(self._consume()) for _ in range(self._size)], ))
-        self._can_be_closed_flag = True
 
 
-AsyncPoolExecutor = AsyncPoolExecutorLtPy310 if sys.version_info.minor < 10 else AsyncPoolExecutorGtPy310
 
 
 

{funboost-49.1 → funboost-49.3}/funboost/concurrent_pool/backup/async_pool_executor_back.py

@@ -4,7 +4,9 @@ import threading
 import time
 import traceback
 from threading import Thread
-import nb_log  # noqa
+import nb_log
+
+from funboost.concurrent_pool.async_helper import get_or_create_event_loop  # noqa
 
 # if os.name == 'posix':
 #     import uvloop
@@ -215,7 +217,7 @@ class AsyncProducerConsumer:
             task.cancel()
 
     def start_run(self):
-        loop = asyncio.get_event_loop()
+        loop = get_or_create_event_loop()
         loop.run_until_complete(self.__run())
         # loop.close()
 

{funboost-49.1 → funboost-49.3}/funboost/constant.py

@@ -1,9 +1,9 @@
 # coding= utf-8
-from calendar import c
+
 
 
 class BrokerEnum:
-    EMPTY = 'empty'  # 空的实现，需要搭配 boost入参的 consumer_override_cls 和 publisher_override_cls使用，或者被继承。
+    EMPTY = 'EMPTY'  # 空的实现，需要搭配 boost入参的 consumer_override_cls 和 publisher_override_cls使用，或者被继承。
 
     RABBITMQ_AMQPSTORM = 'RABBITMQ_AMQPSTORM'  # 使用 amqpstorm 包操作rabbitmq  作为 分布式消息队列，支持消费确认.强烈推荐这个作为funboost中间件。
     RABBITMQ = RABBITMQ_AMQPSTORM
@@ -73,7 +73,7 @@ class BrokerEnum:
     PEEWEE = 'PEEWEE'  # peewee包操作mysql，使用表模拟消息队列
 
     CELERY = 'CELERY'  # funboost支持celery框架来发布和消费任务，由celery框架来调度执行任务，但是写法简单远远暴击用户亲自使用celery的麻烦程度，
-    # 用户永无无需关心和操作Celery对象实例,无需关心celery的task_routes和include配置,funboost来自动化设置这些celery配置。
+    # 用户永无无需关心和操作Celery对象实例,无需关心celery的task_routes和includes配置,funboost来自动化设置这些celery配置。
 
     DRAMATIQ = 'DRAMATIQ'  # funboost使用 dramatiq 框架作为消息队列，dramatiq类似celery也是任务队列框架。用户使用funboost api来操作dramatiq核心调度。
 
@@ -108,7 +108,10 @@ class ConstStrForClassMethod:
     OBJ_INIT_PARAMS = 'obj_init_params'
     CLS_MODULE = 'cls_module'
     CLS_FILE = 'cls_file'
+
+
 class RedisKeys:
+
     REDIS_KEY_PAUSE_FLAG  = 'funboost_pause_flag' 
     REDIS_KEY_STOP_FLAG = 'funboost_stop_flag'
     QUEUE__MSG_COUNT_MAP = 'funboost_queue__msg_count_map'
@@ -117,10 +120,17 @@ class RedisKeys:
     FUNBOOST_QUEUE__RUN_FAIL_COUNT_MAP = 'funboost_queue__run_fail_count_map'
     FUNBOOST_ALL_QUEUE_NAMES = 'funboost_all_queue_names'
     FUNBOOST_ALL_IPS = 'funboost_all_ips'
+    FUNBOOST_LAST_GET_QUEUE_PARAMS_AND_ACTIVE_CONSUMERS_AND_REPORT__UUID_TS = 'funboost_last_get_queue_params_and_active_consumers_and_report__uuid_ts'
+
 
     FUNBOOST_HEARTBEAT_QUEUE__DICT_PREFIX = 'funboost_hearbeat_queue__dict:'
     FUNBOOST_HEARTBEAT_SERVER__DICT_PREFIX = 'funboost_hearbeat_server__dict:'
 
+
+    @staticmethod
+    def gen_funboost_apscheduler_redis_lock_key_by_queue_name(queue_name):
+        return f'funboost.BackgroundSchedulerProcessJobsWithinRedisLock:{queue_name}'
+
     @staticmethod
     def gen_funboost_hearbeat_queue__dict_key_by_queue_name(queue_name):
         return f'{RedisKeys.FUNBOOST_HEARTBEAT_QUEUE__DICT_PREFIX}{queue_name}'
@@ -128,3 +138,17 @@ class RedisKeys:
     @staticmethod
     def gen_funboost_hearbeat_server__dict_key_by_ip(ip):
         return f'{RedisKeys.FUNBOOST_HEARTBEAT_SERVER__DICT_PREFIX}{ip}'
+    
+    @staticmethod
+    def gen_funboost_queue_time_series_data_key_by_queue_name(queue_name):
+        return f'funboost_queue_time_series_data:{queue_name}'
+    
+    @staticmethod
+    def gen_funboost_redis_apscheduler_jobs_key_by_queue_name(queue_name):
+        jobs_key=f'funboost.apscheduler.jobs:{queue_name}'
+        return jobs_key
+    
+    @staticmethod
+    def gen_funboost_redis_apscheduler_run_times_key_by_queue_name(queue_name):
+        run_times_key=f'funboost.apscheduler.run_times:{queue_name}'
+        return run_times_key