Python中如何使用线程装饰器实现异步编程？ 

import time
def run_async(func):
    from threading import Thread
    from functools import wraps
    @wraps(func)
    def async_func(*args, **kwargs):
        func_hl = Thread(target = func, args = args, kwargs = kwargs)
        func_hl.start()
        # func_hl.join(),  阻塞主进程（挡住，无法执行 join 以后的语句），专注执行多线程。
        # func_hl.join(2), 设置参数后，则等待该线程这么长时间就不管它了（而该线程并没有结束）。不管的意思就是可以执行后面的主进程了。
        return func_hl
    return async_func

@run_async
def child():
time.sleep(4)
print(‘thread child’)


@run_async
def child1():
time.sleep(2)
print(‘thread child1’)


def main():
child()
child1()
print(‘Done’)

In [27]: main() Done

In [28]: thread child1 thread child


Python中如何使用线程装饰器实现异步编程？

4 回复

例子会有创建孤儿进程的可能


Python里没有内置的“线程装饰器”能直接把函数变成异步的。不过，我们可以用threading模块和自定义装饰器来模拟这个效果，让函数在后台线程里跑，不阻塞主程序。这本质上还是多线程，不是真正的asyncio那种协程异步。

下面是一个具体的实现例子：

import threading
import functools
import time

def run_in_thread(func):
    """装饰器：将被装饰的函数放在新线程中执行"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        thread = threading.Thread(target=func, args=args, kwargs=kwargs)
        thread.start()
        return thread  # 返回线程对象，方便后续join或管理
    return wrapper

# 使用装饰器
@run_in_thread
def long_running_task(name, delay):
    """一个模拟的耗时任务"""
    print(f"任务 {name} 开始，将休眠 {delay} 秒")
    time.sleep(delay)
    print(f"任务 {name} 完成")

# 主程序
if __name__ == "__main__":
    print("主程序开始")
    
    # 启动两个“异步”任务
    t1 = long_running_task("A", 3)
    t2 = long_running_task("B", 2)
    
    print("主程序继续执行其他操作...")
    
    # 可选：等待所有线程完成
    t1.join()
    t2.join()
    
    print("主程序结束")

关键点解释：

  1. 装饰器run_in_thread会创建一个新线程来执行被装饰的函数。
  2. 函数调用会立即返回一个threading.Thread对象，不会阻塞主线程。
  3. 你可以用.join()来等待线程结束，或者不管它（“即发即忘”模式）。

注意： 这和多线程编程有同样的问题，比如线程安全、GIL限制。对于I/O密集型任务，用asyncio+async/await通常更高效；对于CPU密集型任务，可能要用multiprocessing。

简单说，想方便地让函数在后台跑可以用这个装饰器，但别指望它能解决所有并发问题。

订正，例子应该是不会有问题的

这不就相当于多开了一个线程跑这个函数么。。。

回到顶部