这是生产者消费者类型的疯狂实现吗？

Question

# file1.py

class _Producer(self):

  def __init__(self):
    self.chunksize = 6220800
    with open('/dev/zero') as f:
      self.thing = f.read(self.chunksize)
    self.n = 0
    self.start()

  def start(self):
    import subprocess
    import threading

    def produce():
      self._proc = subprocess.Popen(['producer_proc'], stdout=subprocess.PIPE)
      while True:
        self.thing = self._proc.stdout.read(self.chunksize)
        if len(self.thing) != self.chunksize:
          msg = 'Expected {0} bytes.  Read {1} bytes'.format(self.chunksize, len(self.thing))
          raise Exception(msg)
        self.n += 1

    t = threading.Thread(target=produce)
    t.daemon = True
    t.start()
    self._thread = t

  def stop(self):
    if self._thread.is_alive():
      self._proc.terminate()
      self._thread.join(1)

producer = _Producer()
producer.start()

我编写了一些或多或少类似于上述设计的代码，现在我希望能够通过以下方式使用其他文件中的 Producer_proc 的输出：

# some_other_file.py
import file1
my_thing = file1.producer.thing 

多个其他消费者可能会获取对 的引用>file. Producer.thing ，它们都需要从同一个Producer_proc 使用。并且Producer_proc 永远不应该被阻塞。这是一个合理的实施吗？ python GIL 是否使其线程安全，或者我是否需要使用队列重新实现来获取工作线程的数据？消费者是否需要明确复制该物品？

我想我正在尝试实现诸如生产者/消费者模式或观察者模式之类的东西，但我不太清楚设计模式的所有技术细节。

• 单个生产者不断地制造东西
• 多个消费者在任意时间使用东西
• Producer.thing 一旦新的东西可用，就应该用新的东西替换，大多数东西都会被闲置，但这没关系，
• 没关系让多个消费者阅读同一个内容，或者连续阅读同一个内容两次。他们只想确保在要求时得到的是最新的东西，而不是一些过时的旧东西。
• 消费者应该能够继续使用一个东西，只要他们在范围内，即使生产者可能已经用一个新的东西覆盖了他的 self.thing 。

Answer 1

鉴于您的（不寻常！）要求，您的实现似乎是正确的。特别是，

• 如果您只更新一个属性，Python GIL 应该就足够了。单字节码指令是原子的。
• 如果您要做更复杂的事情，请添加锁定！无论如何，它基本上是无害的 - 如果您关心性能或多核可扩展性，您可能不会使用 Python！
• 特别要注意的是，此代码中的 self.thing 和 self.n 是在单独的字节码指令中更新的。 GIL 可以在两者之间释放/获取，因此除非添加锁定，否则无法获得两者的一致视图。如果您不打算这样做，我建议删除 self.n 因为它是一个“有吸引力的麻烦”（很容易被误用），或者至少添加带有此警告的注释/文档字符串。
• 消费者不需要复制。你永远不会改变 self.thing 指向的特定对象（并且不能使用字符串对象；它们是不可变的）并且 Python 是垃圾收集的，所以只要消费者抓住对它的引用，它可以继续访问它，而不必过多担心其他线程正在做什么。最糟糕的情况可能是您的程序使用了几代 self.thing 保持活动状态的大量内存。

我有点好奇你的要求从何而来。特别是，您不关心事物是否从未使用过或使用过多次。