0
点赞
收藏
分享

微信扫一扫

Mysql-基础-DDL操作

小云晓云 2024-07-24 阅读 27

在这里插入图片描述

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中,我们可以使用asyncawait关键字来编写协程。例如:

async def my_function(data):
    print(data)

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

asyncio.run(main())

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

举报

相关推荐

0 条评论