Question

我很久以前就开始使用多处理了，它正在研究基本的例子。之后我尝试实现某种多声道输入程序，并尝试通过队列将输入通量输入到某个处理模块，这当前严重失败。我将在3点描述我的问题：文件夹结构，流程结构，我尝试过的。

文件夹结构

根文件夹
- 应用
  - start_applicaton.py
  - input_cfg.ini
- 核心
  - core.py
  - gui.py
  - audio_recorder.py（使用sounddevice.InputStream）
  - x_recorder.py

流程结构 当我开始运行我的应用程序时，会调用gui，在按下开始按钮后会创建进程。

主要流程
audio_recorder_1流程
audio_recorder_处理
申请流程

我尝试了什么

core.py

from multiprocessing import Queue, Process
central_queue = Queue()
...
d = {}
d['output'] = central_queue
o = AudioRecorder('name', **d)

start_application.py

import core
def handle_queue_data():
    while True:
        print(str(core.central_queue.get()))
if __name__ == "__main__":
    Process(target=handle_queue_data, name="syncOutput").start()

audio_recorder.py

class AudioRecorder(object):
    def __init__(self, name, **d):
        ...
        self.output_queue = d['output']
    def run(self):
        queue = Queue()
        def callback(indata, frames, time, status):
            if status:
                print(status, flush=True)
            # Push the got data into the queue
            queue.put([indata.copy()])
        with sd.InputStream(samplerate=self.sample_rate, device=self.device_id, channels=self.channel_id, callback=callback):
            while True:
                self.output_queue.put(queue.get())

没用。在调试之后，似乎在从记录器的core.py开始之后，队列的引用已经改变了... FYI调试信息：

# in the audio_recorder.py object
centralized_queue = {Queue} <multiprocessing.queues.Queue object at 0x00000000086B3320>
 _buffer = {deque} deque([[array([[-0.01989746, -0.02053833],\n       [-0.01828003, -0.0196228 ],\n       [-0.00634766, -0.00686646],\n       ..., \n       [-0.01119995, -0.01144409],\n       [-0.00900269, -0.00982666],\n       [-0.00823975, -0.00888062]], dtype=float32)]])
 _close = {Finalize} <Finalize object, callback=_finalize_close, args=[deque([[array([[-0.01989746, -0.02053833],\n       [-0.01828003, -0.0196228 ],\n       [-0.00634766, -0.00686646],\n       ..., \n       [-0.01119995, -0.01144409],\n       [-0.00900269, -0.00982666],\n       [-0
 _closed = {bool} False
 _ignore_epipe = {bool} False
 _joincancelled = {bool} False
 _jointhread = {Finalize} <Finalize object, callback=_finalize_join, args=[<weakref at 0x00000000083A2638; to 'Thread' at 0x0000000004DF1B00>], exitprority=-5>
 _maxsize = {int} 2147483647
 _notempty = {Condition} <Condition(<unlocked _thread.lock object at 0x0000000004738198>, 0)>
 _opid = {int} 1320
 _reader = {PipeConnection} <multiprocessing.connection.PipeConnection object at 0x00000000086B34A8>
 _rlock = {Lock} <Lock(owner=None)>
 _sem = {BoundedSemaphore} <BoundedSemaphore(value=2147483645, maxvalue=2147483647)>
 _thread = {Thread} <Thread(QueueFeederThread, started daemon 9344)>
 _wlock = {NoneType} None
 _writer = {PipeConnection} <multiprocessing.connection.PipeConnection object at 0x00000000086B3518>

# in the handle_queue_data
centralized_queue = {Queue} <multiprocessing.queues.Queue object at 0x000000000479DA20>
 _buffer = {deque} deque([])
 _close = {NoneType} None
 _closed = {bool} False
 _ignore_epipe = {bool} False
 _joincancelled = {bool} False
 _jointhread = {NoneType} None
 _maxsize = {int} 2147483647
 _notempty = {Condition} <Condition(<unlocked _thread.lock object at 0x00000000058C8350>, 0)>
 _opid = {int} 7208
 _reader = {PipeConnection} <multiprocessing.connection.PipeConnection object at 0x000000000684C438>
 _rlock = {Lock} <Lock(owner=None)>
 _sem = {BoundedSemaphore} <BoundedSemaphore(value=2147483647, maxvalue=2147483647)>
 _thread = {NoneType} None
 _wlock = {NoneType} None
 _writer = {PipeConnection} <multiprocessing.connection.PipeConnection object at 0x00000000058DE6A0>

我之后尝试过使用不同的东西，所有不成功，我都没有设法传递数据......队列是否可能是一个可变对象？或者多处理中存在一个错误（非常不可能），或者声音设备的组合会使队列不稳定？

对不起，我的描述很长......

我事先感谢你的帮助！最好的问候，
塞巴斯蒂安

Answer 1

我真的没有使用multiprocessing的经验，但我的理解是start_application.py的模块命名空间中的所有对象都为每个进程重复。如果我没弄错的话，这包括core模块。因此，core.central_queue为每个进程都有一个单独的实例。至少在Windows上似乎是这种情况，Python docs建议“明确地将资源传递给子进程”。

您应该使用if __name__ == '__main__':块来创建Queue的唯一实例和AudioRecorder的唯一实例。然后，您可以使用args Process参数将这些唯一实例传递给您的流程（如上面的链接所示）。

除此之外，我真的不知道你想要实现的目标。您是否希望使用随机的一个可用进程处理音频输入的随机块？或者您是否希望为每个流程提供完整相同的音频输入？

在后一种情况下，每个子进程都应该有一个单独的队列！ sd.InputStream应该仍然是唯一的。在您的with语句中，您应该遍历所有子进程并将当前的音频块分别放入每个进程队列中。

PS：我刚刚意识到您可能出于某种原因只想启动一个额外的流程。在这种情况下，您应该考虑删除整个multiprocessing混乱，并在with语句中执行您需要执行的操作。

<强>更新

如果您想同时使用多个音频设备（以及多个PortAudio流），您仍然不一定需要multiprocessing。您可以拥有一个包含多个上下文管理器的with语句，并在那里进行处理。

根据您要实现的目标，您可能只有一个队列，其中所有音频回调都会写入，或者每个回调都有一个队列。

如果您有充分的理由使用multiprocessing，如果您在主进程中启动所有音频流并在新的子进程中进行处理，它也应该可以正常工作。

Python - 多处理 - 队列：即使它是同一个对象，我的队列引用也会改变吗？

1 个答案: