multithreading - 观察员是否应该在每个单独的线程中得到通知？

Question

我知道这听起来很沉重，但我正在尝试解决一个假设的情况。假设您有N个对象的观察者。每个对对象状态感兴趣的人。当应用Observer Pattern时，可观察对象倾向于遍历其观察者列表，并调用观察者notify()|update()方法。

现在，想象一个特定的观察者与可观察对象的状态有很多工作要做。例如，这将减慢上一个通知的速度。

因此，为了避免减慢向所有观察者的通知速度，我们可以做的一件事是在单独的线程中通知观察者。为了使它起作用，我认为每个观察者都需要一个线程。为了避免由于繁重的工作而导致通知速度变慢，这是一个痛苦的开销。如果使用线程方法，比减慢速度最糟糕的是死循环导致的死循环。读一读有经验的程序员，这将是很棒的。

有多年设计问题的人怎么想？

这是没有实质性解决方案的问题吗？

这真的是个坏主意吗？为什么？

例子

这是一个模糊的示例，目的是演示并希望阐明我什至没有测试过的基本概念:

class Observable(object):
    def __init__(self):
        self.queues = {}

    def addObserver(self, observer):
        if not observer in self.queues:
            self.queues[observer] = Queue()
            ot = ObserverThread(observer, self.queues[observer])
            ot.start()

    def removeObserver(self, observer):
        if observer in self.queues:
            self.queues[observer].put('die')
            del self.queues[observer]

    def notifyObservers(self, state):
        for queue in self.queues.values():
            queue.put(state)

class ObserverThread(Thread):
    def __init__(self, observer, queue):
        self.observer = observer
        self.queue = queue

    def run(self):
        running = True
        while running:
            state = self.queue.get()
            if state == 'die':
                running = False
            else:
                self.observer.stateChanged(state)

Answer 1

您走在正确的轨道上。

每个观察者通常拥有自己的输入队列和消息处理线程(或者更好:队列将拥有线程，观察者将拥有队列)。参见Active object pattern。

但是有一些陷阱:

如果您有100或1000个观察者，则可能需要使用thread pool pattern

注意，您将无法控制事件的处理顺序(观察者将首先处理事件)。这可能不是问题，也可能会打开一个很难检测到的错误的Pandora框。这取决于您的特定应用程序。

您可能必须处理在通知者之前删除观察者的情况。正确处理可能有些棘手。

您将需要实现消息而不是调用函数。消息生成可能需要更多资源，因为您可能需要分配内存，复制对象等。您甚至可能希望通过为常见消息类型实现消息池来进行优化(您也可以选择实现包装此类池的消息工厂。 )。

为了进一步优化，您可能希望生成一条消息并将其发送给所有观察者(而不是生成同一条消息的多个副本)。您可能需要对消息使用某种reference counting机制。