# -*- coding: utf-8 -*-
# 基于python Threading模块封装的异步函数装饰器
import time
from functools import wraps
from threading import Thread


def async_call(fn):
    """一次简单的异步处理操作，装饰在要异步执行的函数前，再调用该函数即可执行单次异步操作(开辟一条新的线程)

    Args:
        :fn(function):需要异步处理的方法

    Return:
        :wrapper(function):
    """

    @wraps(fn)  # 解决被装饰的函数的名字会变成装饰器函数，并还原函数名称
    def wrapper(*args, **kwargs):
        Thread(target=fn, args=args, kwargs=kwargs).start()

    return wrapper


def async_pool(pool_links):
    """可定义链接数的线程池装饰器，可用于并发执行多次任务

    Args:
        :pool_links(int):进程的数量
    
    Returns:
        :sub_wrapper(function):对象装饰器
    """

    def sub_wrapper(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(0, pool_links):
                Thread(target=func, args=args, kwargs=kwargs).start()
                # func(*args, **kwargs)

        return wrapper

    return sub_wrapper


def async_retry(retry_times, space_time):
    """自动重试类装饰器，不支持单独异步，但可嵌套于 call 和 pool中使用

    Args:
        :retry_times(int):重试次数
    """

    def sub_wrapper(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            try_times = retry_times
            while try_times > 0:
                try:
                    func(*args, **kwargs)
                    break
                except Exception as e:
                    print(e)
                    time.sleep(space_time)
                    try_times = try_times - 1

        return wrapper

    return sub_wrapper


# 以下为测试案例代码


# @async_call
# def sleep2andprint():
#     time.sleep(2)
#     print('22222222')


# @async_pool(pool_links=5)
# def pools():
#     time.sleep(1)
#     print('hehe')


# @async_retry(retry_times=3, space_time=1)
# def check():
#     a = 1
#     b = '2'
#     print(a + b)


# def check_all():
#     print('正在测试async_call组件')
#     print('111111')
#     sleep2andprint()
#     print('333333')
#     print('若3333出现在22222此前，异步成功')
#     print('正在测试async_pool组件')
#     pools()
#     print('在一秒内打印出5个hehe为成功')
#     print('正在测试async_retry组件')
#     check()
#     print('打印三次异常则成功')
#     print(check.__name__)
#     print(sleep2andprint.__name__)
#     print(pools.__name__)


# check_all()


ed19fea5169c4a03451924d0047101594bf58476
<mask token>


def async_pool(pool_links):
    """可定义链接数的线程池装饰器，可用于并发执行多次任务

    Args:
        :pool_links(int):进程的数量
    
    Returns:
        :sub_wrapper(function):对象装饰器
    """

    def sub_wrapper(func):

        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(0, pool_links):
                Thread(target=func, args=args, kwargs=kwargs).start()
        return wrapper
    return sub_wrapper


<mask token>

<mask token>


def async_pool(pool_links):
    """可定义链接数的线程池装饰器，可用于并发执行多次任务

    Args:
        :pool_links(int):进程的数量
    
    Returns:
        :sub_wrapper(function):对象装饰器
    """

    def sub_wrapper(func):

        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(0, pool_links):
                Thread(target=func, args=args, kwargs=kwargs).start()
        return wrapper
    return sub_wrapper


def async_retry(retry_times, space_time):
    """自动重试类装饰器，不支持单独异步，但可嵌套于 call 和 pool中使用

    Args:
        :retry_times(int):重试次数
    """

    def sub_wrapper(func):

        @wraps(func)
        def wrapper(*args, **kwargs):
            try_times = retry_times
            while try_times > 0:
                try:
                    func(*args, **kwargs)
                    break
                except Exception as e:
                    print(e)
                    time.sleep(space_time)
                    try_times = try_times - 1
        return wrapper
    return sub_wrapper

<mask token>


def async_call(fn):
    """一次简单的异步处理操作，装饰在要异步执行的函数前，再调用该函数即可执行单次异步操作(开辟一条新的线程)

    Args:
        :fn(function):需要异步处理的方法

    Return:
        :wrapper(function):
    """

    @wraps(fn)
    def wrapper(*args, **kwargs):
        Thread(target=fn, args=args, kwargs=kwargs).start()
    return wrapper


def async_pool(pool_links):
    """可定义链接数的线程池装饰器，可用于并发执行多次任务

    Args:
        :pool_links(int):进程的数量
    
    Returns:
        :sub_wrapper(function):对象装饰器
    """

    def sub_wrapper(func):

        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(0, pool_links):
                Thread(target=func, args=args, kwargs=kwargs).start()
        return wrapper
    return sub_wrapper


def async_retry(retry_times, space_time):
    """自动重试类装饰器，不支持单独异步，但可嵌套于 call 和 pool中使用

    Args:
        :retry_times(int):重试次数
    """

    def sub_wrapper(func):

        @wraps(func)
        def wrapper(*args, **kwargs):
            try_times = retry_times
            while try_times > 0:
                try:
                    func(*args, **kwargs)
                    break
                except Exception as e:
                    print(e)
                    time.sleep(space_time)
                    try_times = try_times - 1
        return wrapper
    return sub_wrapper

import time
from functools import wraps
from threading import Thread


def async_call(fn):
    """一次简单的异步处理操作，装饰在要异步执行的函数前，再调用该函数即可执行单次异步操作(开辟一条新的线程)

    Args:
        :fn(function):需要异步处理的方法

    Return:
        :wrapper(function):
    """

    @wraps(fn)
    def wrapper(*args, **kwargs):
        Thread(target=fn, args=args, kwargs=kwargs).start()
    return wrapper


def async_pool(pool_links):
    """可定义链接数的线程池装饰器，可用于并发执行多次任务

    Args:
        :pool_links(int):进程的数量
    
    Returns:
        :sub_wrapper(function):对象装饰器
    """

    def sub_wrapper(func):

        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(0, pool_links):
                Thread(target=func, args=args, kwargs=kwargs).start()
        return wrapper
    return sub_wrapper


def async_retry(retry_times, space_time):
    """自动重试类装饰器，不支持单独异步，但可嵌套于 call 和 pool中使用

    Args:
        :retry_times(int):重试次数
    """

    def sub_wrapper(func):

        @wraps(func)
        def wrapper(*args, **kwargs):
            try_times = retry_times
            while try_times > 0:
                try:
                    func(*args, **kwargs)
                    break
                except Exception as e:
                    print(e)
                    time.sleep(space_time)
                    try_times = try_times - 1
        return wrapper
    return sub_wrapper

# -*- coding: utf-8 -*-
# 基于python Threading模块封装的异步函数装饰器
import time
from functools import wraps
from threading import Thread


def async_call(fn):
    """一次简单的异步处理操作，装饰在要异步执行的函数前，再调用该函数即可执行单次异步操作(开辟一条新的线程)

    Args:
        :fn(function):需要异步处理的方法

    Return:
        :wrapper(function):
    """

    @wraps(fn)  # 解决被装饰的函数的名字会变成装饰器函数，并还原函数名称
    def wrapper(*args, **kwargs):
        Thread(target=fn, args=args, kwargs=kwargs).start()

    return wrapper


def async_pool(pool_links):
    """可定义链接数的线程池装饰器，可用于并发执行多次任务

    Args:
        :pool_links(int):进程的数量
    
    Returns:
        :sub_wrapper(function):对象装饰器
    """

    def sub_wrapper(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(0, pool_links):
                Thread(target=func, args=args, kwargs=kwargs).start()
                # func(*args, **kwargs)

        return wrapper

    return sub_wrapper


def async_retry(retry_times, space_time):
    """自动重试类装饰器，不支持单独异步，但可嵌套于 call 和 pool中使用

    Args:
        :retry_times(int):重试次数
    """

    def sub_wrapper(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            try_times = retry_times
            while try_times > 0:
                try:
                    func(*args, **kwargs)
                    break
                except Exception as e:
                    print(e)
                    time.sleep(space_time)
                    try_times = try_times - 1

        return wrapper

    return sub_wrapper


# 以下为测试案例代码


# @async_call
# def sleep2andprint():
#     time.sleep(2)
#     print('22222222')


# @async_pool(pool_links=5)
# def pools():
#     time.sleep(1)
#     print('hehe')


# @async_retry(retry_times=3, space_time=1)
# def check():
#     a = 1
#     b = '2'
#     print(a + b)


# def check_all():
#     print('正在测试async_call组件')
#     print('111111')
#     sleep2andprint()
#     print('333333')
#     print('若3333出现在22222此前，异步成功')
#     print('正在测试async_pool组件')
#     pools()
#     print('在一秒内打印出5个hehe为成功')
#     print('正在测试async_retry组件')
#     check()
#     print('打印三次异常则成功')
#     print(check.__name__)
#     print(sleep2andprint.__name__)
#     print(pools.__name__)


# check_all()

