python多进程队列的底层进程是什么？

有人详细解释过python多处理队列通信吗？将参数放入队列时发生了什么？我有一段代码，这让我很困惑

import time
import numpy as np
from multiprocessing import Queue, Process


def task(queue_in, queue_out):
    mutural_np = np.zeros((10, 2))
    while True:
        msg = queue_in.get()
        res = []
        i = 0
        for i in range(msg):
            newnp = np.ones((1, 2)) * (msg - i)
            mutural_np[i:i+1] = newnp
        res = mutural_np[:i]
        print("===> put: ", res)
        queue_out.put(res)


if __name__ == "__main__":
    queue_in = Queue(10)
    queue_out = Queue(1)
    p1 = Process(target=task, args=(queue_in, queue_out))
    p1.start()
    for i in range(5):
        queue_in.put(i + 1)

    while True:
        msg = queue_out.get()
        time.sleep(0.5)
        print("***> out: ", msg)

输出为：

===> put:  []
===> put:  [[2. 2.]]
===> put:  [[3. 3.]
 [2. 2.]]
***> out:  []
===> put:  [[4. 4.]
 [3. 3.]
 [2. 2.]]
***> out:  [[3. 3.]]
===> put:  [[5. 5.]
 [4. 4.]
 [3. 3.]
 [2. 2.]]
***> out:  [[4. 4.]
 [3. 3.]]
***> out:  [[5. 5.]
 [4. 4.]
 [3. 3.]]
***> out:  [[5. 5.]
 [4. 4.]
 [3. 3.]
 [2. 2.]]

为什么我会有这种不一致

我看到医生说

将对象放入队列时，对象将被pickle，后台线程随后将pickle数据刷新到底层管道

“pickle模块跟踪已序列化的对象，以便以后对同一对象的引用不会再次序列化”

---

根据我的理解，当我将对象放入队列中时，它是经过pickle处理的且不可变的，但它似乎是在被清除之后发生的。

我想我是通过阅读源代码得到答案的

---

当我将对象放入进程队列时，Python启动一个线程来序列化和发送数据。因此，为了安全起见，请在将其放入队列之前复制一份。

当您尝试阅读文档时发生了什么？堆栈溢出不是一个讨论论坛；我们只能帮助您理解一些东西，如果您提出一个特定的问题（并证明您找到了文档，阅读了相关部分，仍然有理由感到困惑），而不仅仅是“这件事是如何工作的？”。我的问题是，为什么我从上面的代码中得到与文档不一致的输出。谢谢，你的预期产量是多少？文档讨论的是当您编写一个由其他对象组成的复杂对象时，这些对象可能多次包含对同一对象的引用，包括循环引用。在这种情况下，它将认识到其中一个组合对象已经被序列化，并且不会不必要地再次重新序列化它（或者当它是循环引用时进入无止境的循环）。但是，如果您将上次写入队列时写入队列的对象写入队列，则该对象将被写出。还有别的选择吗？嘿，波波。我想知道为什么从队列中获取的值与我输入的值不同。第二个put是[[2.2.]]，但是我得到[[3.3.]]，我刚刚看到了你最后的评论。如果要编写注释并确保通知某人，则必须开始编写以

@

字符开头的用户名，然后自动完成用户名。所以在我的例子中，你应该使用

@Booboo

而不是

Booboo

。不管怎样，这就是为什么指定您的预期输出总是一个好主意；我完全误解了你的问题。