【问题标题】:Prevent reading data from an empty FIFO from blocking防止从空 FIFO 读取数据阻塞
【发布时间】:2016-11-01 01:13:45
【问题描述】:

在 Python 3 Web 应用程序中,我需要使用命令行实用程序来处理图像,将其输出写入命名管道 (fifo),然后将该输出(管道的内容)解析为PIL/枕头图像。这是基本流程(和工作代码这么长,没有错误!):

from os import mkfifo
from os import unlink
from PIL import Image
from subprocess import DEVNULL
from subprocess import PIPE
from subprocess import Popen

fifo_path = '/tmp/myfifo.bmp'
cmd = '/usr/bin/convert -resize 100 /path/to/some.tif ' + fifo_path
# make a named pipe
mkfifo(fifo_path)
# execute
proc = Popen(cmd, stdout=DEVNULL, stderr=PIPE, shell=True)
# parse the image
pillow_image = Image.open(fifo_path)
# finish the process:
proc_exit = proc.wait()
# remove the pipe:
unlink(fifo_path)
# just for proof:
pillow_image.show()

(在上面的示例中,我已经用 ImageMagick 替换了我实际必须使用的实用程序,只是因为您不太可能拥有它——它根本不会影响问题。)

这在大多数情况下都很好用,并且我可以处理大多数异常(为清楚起见,上面省略了),但是有一种情况我无法弄清楚如何处理,如果出现问题该怎么办外壳,导致空管道,例如如果图像不存在或由于某种原因损坏,例如:

fifo_path = '/tmp/myfifo.bmp'
cmd = '/usr/bin/convert -resize 100 /path/to/some/bad_or_missing.tif ' + fifo_path
# make a named pipe
mkfifo(fifo_path)
# execute
proc = Popen(cmd, stdout=DEVNULL, stderr=PIPE, shell=True)
# parse the image
pillow_image = Image.open(fifo_path) # STUCK
...

应用程序在这里挂起,因为我无法访问proc_exit = proc.wait(),所以我无法设置timeout(例如proc_exit = proc.wait(timeout=2)),这是我通常会做的。

我尝试将整个业务封装在上下文管理器中,类似于 this answer,但该方法不是线程安全的,这是一个问题,我找不到可以让我访问的线程或多处理解决方案当我加入线程或进程时到 PIL/Pillow Image 实例(不是我的强项,而是这样的东西):

from multiprocessing import Process
from os import mkfifo
from os import unlink
from PIL import Image
from subprocess import DEVNULL
from subprocess import PIPE
from subprocess import Popen

def do_it(cmd, fifo_path):
    mkfifo(fifo_path)
    # I hear you like subprocesses with your subprocesses...
    sub_proc = Popen(cmd, stdout=DEVNULL, stderr=PIPE, shell=True)
    pillow_image = Image.open(fifo_path)
    proc_exit = sub_proc.wait()
    unlink(fifo_path)

fifo_path = '/tmp/myfifo.bmp'
cmd = '/usr/bin/convert -resize 100 /path/to/some/bad_or_missing.tif ' + fifo_path
proc = Process(target=do_it, args=(cmd, fifo_path))
proc.daemon = True
proc.start()
proc.join(timeout=3) # I can set a timeout here
# Seems heavy anyway, and how do I get pillow_image back for further work?
pillow_image.show()

希望这些能说明我的问题和我的尝试。提前致谢。

【问题讨论】:

  • 命令出错时不会退出吗?这将关闭管道,你会得到一个空响应,它不会阻塞。
  • 直到proc.wait(),直到读取fifo中的数据后我才能调用它。
  • 我刚刚注意到您使用的是命名管道,而不是让命令写入stdout。因此,如果输入文件出错,它永远不会打开输出管道。你能改变它,让它写入标准输出吗?
  • 如果不能更改命令,可以使用/dev/stdout 代替命名管道。
  • 也许可以用后缀符号链接到/dev/stdout。

标签: python python-3.x subprocess


【解决方案1】:

POSIX read(2):

尝试从空管道或 FIFO 中读取时:

如果没有进程打开管道进行写入,read() 将返回 0 到 表示文件结束。

Image.open(fifo_path) 可能会卡住当且仅当命令死亡而在被阻塞时打开fifo_path 进行写入。

Normally, opening the FIFO blocks until the other end is opened also.

这是一个正常的顺序:

  1. cmd 在尝试打开 fifo_open 进行写入时阻塞
  2. 您的 Python 代码在尝试打开进行阅读时阻塞
  3. 一旦两个进程都打开了 FIFO,数据流就会开始。除了名称,FIFO 类似于管道——只有一个管道对象——内核在内部传递所有数据而不将其写入文件系统。@987654323 @
  4. cmd 关闭管道的末端。您的代码收到 EOF,因为没有其他进程打开 FIFO 进行写入并且 Image.open(fifo_path) 返回。

    cmd 的管道末端为什么会因为成功完成或错误而关闭,不管cmd 是否被突然杀死:只要它的末端是关闭的。

    您的进程是否调用proc.wait() 并不重要。 proc.wait() 不会杀死 cmd。 proc.wait() 不会阻止管道的另一端打开或关闭。 proc.wait() 唯一要做的就是等到子进程死亡和/或返回已经死亡的子进程的退出状态。

这是死锁情况:

  1. 在调用Image.open() 时,cmd 甚至不会尝试打开fifo_open 以进行写入,例如,没有/usr/bin/convert、错误的命令行参数、错误/无输入,等等
  2. 您的 Python 代码在尝试打开进行阅读时阻塞

fifo_open 未打开以供写入,因此Image.open(fifo_open) 一直卡在试图打开它以供阅读。


您可以在后台线程中打开 FIFO 进行写入,并在父级打开 FIFO 进行读取时关闭它:

#!/usr/bin/env python3
import contextlib
import os
import subprocess
import sys
import textwrap
import threading

fifo_path = "fifo"
with contextlib.ExitStack() as stack:
    os.mkfifo(fifo_path)
    stack.callback(os.remove, fifo_path)
    child = stack.enter_context(
        subprocess.Popen([
            sys.executable, '-c', textwrap.dedent('''
            import random
            import sys
            import time
            if random.random() < 0.5: # 50%
                open(sys.argv[1], 'w').write("ok")
            else:
                sys.exit("fifo is not opened for writing in the child")
            '''), fifo_path
        ]))
    stack.callback(child.kill)
    opened = threading.Event()  # set when the FIFO is opened for reading
    threading.Thread(target=open_for_writing, args=[fifo_path, opened, child],
                     daemon=True).start()
    pipe = stack.enter_context(open(fifo_path))  # open for reading
    opened.set()  # the background thread may close its end of the pipe now
    print(pipe.read()) # read data from the child or return in 3 seconds
sys.exit(child.returncode)

在 EOF 上,孩子被杀死。

open_for_writing() 打开 FIFO,解除对open(fifo_path) 的阻塞,这反过来又可以关闭它。为避免pipe.read() 过早返回,给孩子 3 秒时间打开 FIFO 进行写入:

def open_for_writing(path, opened, child):
    with open(path, 'w'):
        opened.wait()  # don't close until opened for reading in the main thread
        try:
            child.wait(timeout=3)  # the child has 3 seconds to open for writing
        except subprocess.TimeoutExpired:
            pass

如果您确定子进程尝试打开 FIFO 或最终退出(或者您可以接受 Python 进程在子进程运行时挂起,那么您可以放弃超时并使用 child.wait() 而不是 @987654351 @. 有了这个改变,就没有任意超时了,代码可能在任意慢的系统上运行(无论出于何种原因)。

代码演示了为什么应该尽可能避免使用线程,或者为什么应该更喜欢已建立的模式(不太通用但可以保证正确工作),例如通过通信进行同步。

答案中的代码应该适用于各种情况,但各部分错综复杂。在一个非常具体的案例出现之前,即使是很小的变化也可能不会产生明显的影响。

【讨论】:

  • 哇,这看起来很有希望!与此同时,我不得不继续对文件系统进行 shellout,但期待尝试一下。谢谢!
猜你喜欢
  • 1970-01-01
  • 2017-04-26
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2018-04-02
  • 2021-06-24
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多