1、问题背景

在Python中，我想创建一个由事件生成控制流程的类结构。为此，我做了以下工作：

class MyEvent:  
    EventName_FunctionName = {}

    @classmethod
    def setup(cls, notificationname, functionname):
        if notificationname in MyEvent.EventName_FunctionName.keys():
            MyEvent.EventName_FunctionName[notificationname].append(functionname)
        else:
            MyEvent.EventName_FunctionName[notificationname] = [functionname]

    @classmethod    
    def runonnotification(cls, notificationname, *args):
        thisfunclist = MyEvent.EventName_FunctionName[notificationname]
        for func in thisfunclist:
            if len(args) > 0:
                func(*args)
            else:
                func()

然后，我以以下方式使用它：

from FirstEventClass import MyEvent
class simpleexample:
    def __init__(self,a = 1, b = 2):
        simpleexample.a = a
        simpleexample.b = b
        MyEvent.setup('greater than 100',self.printerror)
        MyEvent.setup('dont do negative',self.negation)
        MyEvent.setup('many values recieved',self.handlemultipleupdates)


    def updation(self,updateval):
        if updateval > 100:
            MyEvent.runonnotification('greater than 100',updateval)
            self.a = updateval
        if updateval < 0:
            MyEvent.runonnotification('dont do negative')


    def multipleupdates(self, a, b):
        MyEvent.runonnotification('many values recieved', a , b)

    def printerror(self,data):
        print ' something has gone wrong' ,data

    def negation(self):
        print 'negation enter'
        self.a = -self.a

    def handlemultipleupdates(self, a , b):
        print 'wow'
        self.a = a
        self.b = b

然而，我的问题是，基本上所有这些事件都是函数调用，在很短的时间内，我构建了一个巨大的递归调用堆栈。我该如何在通知事件的同时退出函数，或者让现有函数在后台线程上继续运行？

2、解决方案

方法一：使用多线程

一种解决方法是使用多线程。我们可以创建一个新线程来运行函数，然后在主线程中等待线程完成。例如：

import threading

def my_function(data):
    print(data)

# Create a new thread
thread = threading.Thread(target=my_function, args=("Hello, world!",))

# Start the thread
thread.start()

# Wait for the thread to finish
thread.join()

方法二：使用异步编程

另一种解决方法是使用异步编程。异步编程允许我们编写并发代码，而无需使用多线程或多进程。在Python中，我们可以使用asyncio库进行异步编程。例如：

import asyncio

async def my_function(data):
    print(data)

# Create an event loop
loop = asyncio.get_event_loop()

# Create a task
task = asyncio.create_task(my_function("Hello, world!"))

# Run the event loop
loop.run_until_complete(task)

方法三：使用协程

协程是一种轻量级的线程，它可以暂停和恢复执行。协程可以用于编写异步代码，而无需使用多线程或多进程。在Python中，我们可以使用async和await关键字来编写协程。例如：

async def my_function(data):
    print(data)

async def main():
    await my_function("Hello, world!")

asyncio.run(main())

这三种方法都可以解决在Python中异步触发事件的问题。我们可以根据自己的需要选择合适的方法。