0

我想制作类结构，其中流程由事件的生成控制。为此，我做了以下事情：

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

但是，我的问题是，基本上所有这些事件都是函数调用，不久之后，我构建了一大堆递归调用。如何在通知事件的同时退出函数，或者继续在后台线程上运行现有函数。

4

1 回答 1

0

你可以：

  • 使用线程池。与进程池相同的接口，但从multiprocessing.poollike so导入from multiprocessing.pool import ThreadPool。

    您可以将事件名称和参数发送到池以供线程处理。如果队列已满，这可能会阻塞。

  • 在数据库中创建一个简单的事件队列（django 模型）并使用单独的进程/线程来处理事件。这不会阻塞，因为您几乎总是可以将新对象添加到数据库中。

  • 查看像celery这样的库，它可以为您提供可扩展性，并可以在队列顶部构建整个事件调度程序。

ThreadPool例子：

from collections import defaultdict
from multiprocessing.pool import ThreadPool


class MyEvent:
    handlers = defaultdict(list)
    _pool = ThreadPool(5)

    @classmethod
    def setup(cls, notificationname, functionname):
        cls.handlers[notificationname].append(functionname)

    @classmethod
    def runonnotification(cls, notificationname, *args):
        thisfunclist = cls.handlers[notificationname]
        for func in thisfunclist:
            cls._pool.apply_async(func, args=args)


class SimpleExample(object):
    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

s = SimpleExample()
for x in [-50, 0, 1, 50, 70, 101]:
    s.updation(x)

MyEvent._pool.close()
MyEvent._pool.join()
于 2013-08-26T18:11:02.573 回答