python管道的同步/异步行为

Question

在我的应用程序中，我使用多处理模块中的管道来在python进程之间进行通信。 最近我发现了一种奇怪的行为，这取决于我通过它们发送的数据的大小。 根据python文档，这些管道基于连接，并且应该以异步方式运行，但有时它们会在发送时陷入困境。 如果我在每个连接中启用全双工，一切正常，即使我没有使用连接进行发送和收听。 谁能解释这种行为？

1. 100个浮点数，全双工禁用
   代码工作，利用异步。
2. 100个浮点数，全双工启用
   该示例正常工作正常。
3. 10000浮动，全双工禁用
   执行被永久阻止，即使它对较小的数据很好。
4. 10000浮动，全双工启用
   好了。

代码（这不是我的生产代码，它只是说明了我的意思）：

from collections import deque
from multiprocessing import Process, Pipe
from numpy.random import randn
from os import getpid

PROC_NR = 4
DATA_POINTS = 100
# DATA_POINTS = 10000


def arg_passer(pipe_in, pipe_out, list_):
    my_pid = getpid()
    print "{}: Before send".format(my_pid)
    pipe_out.send(list_)
    print "{}: After send, before recv".format(my_pid)
    buf = pipe_in.recv()
    print "{}: After recv".format(my_pid)


if __name__ == "__main__":
    pipes = [Pipe(False) for _ in range(PROC_NR)]
    # pipes = [Pipe(True) for _ in range(PROC_NR)]
    pipes_in = deque(p[0] for p in pipes)
    pipes_out = deque(p[1] for p in pipes)
    pipes_in.rotate(1)
    pipes_out.rotate(-1)

    data = [randn(DATA_POINTS) for foo in xrange(PROC_NR)]
    processes = [Process(target=arg_passer, args=(pipes_in[foo], pipes_out[foo], data[foo]))
                 for foo in xrange(PROC_NR)]

    for proc in processes:
        proc.start()

    for proc in processes:
        proc.join()

Answer 1

首先，值得注意的是multiprocessing.Pipe类的实现......

def Pipe(duplex=True):
    '''
    Returns pair of connection objects at either end of a pipe
    '''
    if duplex:
        s1, s2 = socket.socketpair()
        s1.setblocking(True)
        s2.setblocking(True)
        c1 = _multiprocessing.Connection(os.dup(s1.fileno()))
        c2 = _multiprocessing.Connection(os.dup(s2.fileno()))
        s1.close()
        s2.close()
    else:
        fd1, fd2 = os.pipe()
        c1 = _multiprocessing.Connection(fd1, writable=False)
        c2 = _multiprocessing.Connection(fd2, readable=False)

    return c1, c2

不同之处在于半双工'管道'使用匿名管道 ，但全双工'管道'实际上使用Unix域套接字 ，因为匿名管道本质上是单向的。

在这种情况下，我不确定你所说的“异步”是什么意思。 如果您的意思是“非阻塞I / O”，那么值得注意的是两个实现默认使用阻塞I / O.

---

其次，值得注意的是你要发送的数据的腌制大小......

>>> from numpy.random import randn
>>> from cPickle import dumps
>>> len(dumps(randn(100)))
2479
>>> len(dumps(randn(10000)))
237154

---

第三，从pipe(7)页...

管道容量

管道的容量有限。 如果管道已满，则write（2）将阻塞或失败，具体取决于是否设置了O_NONBLOCK标志（见下文）。 不同的实施方式对管道容量有不同的限制。 应用程序不应该依赖于特定的容量：应该设计一个应用程序，以便读取过程一旦可用就会消耗数据，这样写入过程就不会被阻止。

在2.6.11之前的Linux版本中，管道的容量与系统页面大小相同（例如，i386上的4096字节）。 从Linux 2.6.11开始，管道容量为65536字节。

---

因此，实际上，您已经创建了一个死锁，其中所有子pipe_out.send()都在pipe_out.send()调用上被阻塞，并且它们都不能从其他进程接收任何数据，因为您正在发送所有237,154字节的数据一次点击，填充了65,536字节的缓冲区。

您可能只是想使用Unix域套接字版本，但它目前工作的唯一原因是它具有比管道更大的缓冲区大小，并且如果增加DATA_POINTS的数量，您会发现该解决方案也将失败到100,000。

“快速n'脏黑客”解决方案是将数据分成较小的块以便发送，但依赖缓冲区是特定大小并不是一种好的做法。

更好的解决方案是在pipe_out.send()调用上使用非阻塞I / O，尽管我对multiprocessing模块不太熟悉，无法确定使用该模块实现它的最佳方法。

伪代码将沿着...的路线。

while 1:
    if we have sent all data and received all data:
        break
    send as much data as we can without blocking
    receive as much data as we can without blocking
    if we didn't send or receive anything in this iteration:
        sleep for a bit so we don't waste CPU time
        continue

...或者您可以使用Python select模块来避免长时间睡眠，但是，再次将其与multiprocessing.Pipe集成。 multiprocessing.Pipe可能会很棘手。

multiprocessing.Queue类可能会为您完成所有这些，但我以前从未使用它，所以您必须做一些实验。