def multi_processing_consume():
get_consumer('task1_queue', consuming_function=task1,
broker_kind=2).start_consuming_message()
RedisConsumer('task2_queue', consuming_function=task2,
threads_num=100).start_consuming_message()
AbstractConsumer.join_shedual_task_thread(
) # linux多进程启动时候一定要加这一句,否则即使是while 1 的线程如果不join，子进程也会迅速退出。windows下可以不需要这一句。
if random.randint(4, 6) == 5:
raise RandomError('演示随机出错')
logger.info(f'计算 {a} + {b} 得到的结果是 {a + b}')
return a + b
def sub(x, y):
logger.info(f'消费此消息 {x} - {y} 中。。。。。')
time.sleep(0.4) # 模拟做某事需要阻塞10秒种，必须用并发绕过此阻塞。
if random.randint(1, 10) == 4:
raise ValueError('4444')
logger.info(f'计算 {x} - {y} 得到的结果是 {x - y}')
# 把消费的函数名传给consuming_function，就这么简单。
consumer_add = get_consumer('queue_test56', consuming_function=add, threads_num=500, max_retry_times=2,
msg_schedule_time_intercal=0.0007, log_level=10, logger_prefix='zz平台消费',
function_timeout=0, is_print_detail_exception=False,
msg_expire_senconds=3600,
function_result_status_persistance_conf= FunctionResultStatusPersistanceConfig(True, True, 7 * 24 * 3600),
broker_kind=0, concurrent_mode=1,) # 通过设置broker_kind，一键切换中间件为rabbitmq或redis等9种中间件或包。
consumer_sub = get_consumer('queue_test57', consuming_function=sub, threads_num=50, msg_schedule_time_intercal=0.2, log_level=10, logger_prefix='xxxxx平台消费',
function_timeout=80, is_print_detail_exception=True,
broker_kind=2, concurrent_mode=1) # 通过设置
if __name__ == '__main__':
ConsumersManager.show_all_consumer_info()
consumer_add.start_consuming_message()
# consumer_sub.start_consuming_message()
if random.randint(1, 10) == 4000:
raise ValueError('4444')
result = x - y
logger.info(f'计算 {x} - {y} 得到的结果是 {result}')
return result
# 把消费的函数名传给consuming_function，就这么简单。
consumer_add = get_consumer(
'queue_test569',
consuming_function=add,
concurrent_num=5000,
max_retry_times=2,
qps=2,
log_level=10,
logger_prefix='zz平台消费',
function_timeout=0,
is_print_detail_exception=False,
msg_expire_senconds=3600,
function_result_status_persistance_conf=
FunctionResultStatusPersistanceConfig(False, False, 7 * 24 * 3600),
broker_kind=10,
concurrent_mode=1,
) # 通过设置broker_kind，一键切换中间件为rabbitmq或redis等9种中间件或包。
consumer_sub = get_consumer('queue_test86',
consuming_function=sub,
concurrent_num=2000,
qps=108,
log_level=10,
logger_prefix='xxxxx平台消费',
is_print_detail_exception=True,
# -*- coding: utf-8 -*-
# @Author : ydf
# @Time : 2019/8/8 0008 14:57
import time
from function_scheduling_distributed_framework import get_consumer
from function_scheduling_distributed_framework.utils import LogManager
from test_frame.my_patch_frame_config import do_patch_frame_config
do_patch_frame_config()
logger = LogManager('f2').get_logger_and_add_handlers()
def f2(a, b):
logger.info(f'消费此消息 {a} + {b} 中。。。。。')
time.sleep(10) # 模拟做某事需要阻塞10秒种，必须用并发绕过此阻塞。
logger.info(f'计算 {a} + {b} 得到的结果是 {a + b}')
# 把消费的函数名传给consuming_function，就这么简单。
consumer = get_consumer(
'queue_test2', consuming_function=f2,
broker_kind=6) # 通过设置broker_kind，一键切换中间件为mq或redis等7种中间件或包。
if __name__ == '__main__':
consumer.start_consuming_message()
from function_scheduling_distributed_framework import get_consumer, task_deco
def step1(x):
print(f'x 的值是 {x}')
if x == 0:
for i in range(1, 10):
consumer1.publisher_of_same_queue.publish(dict(x=x + i))
for j in range(10):
consumer2.publisher_of_same_queue.publish(dict(y=x * 100 + j))
def step2(y):
print(f'y 的值是 {y}')
consumer1 = get_consumer('queue_test_step1', consuming_function=step1)
consumer2 = get_consumer('queue_test_step2', consuming_function=step2)
consumer1.publisher_of_same_queue.clear()
consumer1.publisher_of_same_queue.publish({'x': 0})
consumer1.start_consuming_message()
consumer2.start_consuming_message()
import time
from function_scheduling_distributed_framework import get_consumer, ConcurrentModeEnum
from function_scheduling_distributed_framework.utils import LogManager
logger = LogManager('f2').get_logger_and_add_handlers()
def f2(a, b):
logger.info(f'消费此消息 {a} + {b} 中。。。。。')
time.sleep(10) # 模拟做某事需要阻塞10秒种，必须用并发绕过此阻塞。
logger.info(f'计算 {a} + {b} 得到的结果是 {a + b}')
# 把消费的函数名传给consuming_function，就这么简单。
consumer = get_consumer('queue_test62',
consuming_function=f2,
concurrent_num=200,
msg_schedule_time_intercal=0.1,
log_level=10,
logger_prefix='zz平台消费',
function_timeout=20,
is_print_detail_exception=True,
msg_expire_senconds=500,
broker_kind=8,
concurrent_mode=ConcurrentModeEnum.GEVENT
) # 通过设置broker_kind，一键切换中间件为mq或redis等7种中间件或包。
if __name__ == '__main__':
consumer.start_consuming_message()
# -*- coding: utf-8 -*-
# @Author : ydf
# @Time : 2019/8/8 0008 14:57
import time
from function_scheduling_distributed_framework import get_consumer
from function_scheduling_distributed_framework.utils import LogManager
logger = LogManager('f2').get_logger_and_add_handlers()
def f2(a, b):
logger.info(f'消费此消息 {a} + {b} 中。。。。。')
time.sleep(3) # 模拟做某事需要阻塞10秒种，必须用并发绕过此阻塞。
logger.info(f'计算 {a} + {b} 得到的结果是 {a + b}')
return a + b
# 把消费的函数名传给consuming_function，就这么简单。
consumer = get_consumer(
'queue_test33',
consuming_function=f2,
is_using_rpc_mode=True,
broker_kind=2,
concurrent_num=1000) # 通过设置broker_kind，一键切换中间件为mq或redis等7种中间件或包。
if __name__ == '__main__':
consumer.start_consuming_message()
"""
测试非装饰器版本方式，注意对比装饰器版本test_decorator_task_example.py
"""
from function_scheduling_distributed_framework import get_consumer
def f(a, b):
print(a + b)
consumer = get_consumer('queue_test_f01',
consuming_function=f,
qps=0.2,
broker_kind=0)
for i in range(10, 20):
consumer.publisher_of_same_queue.publish(dict(a=i, b=i * 2))
consumer.start_consuming_message()