Python ruft einen externen Unterprozess auf, um asynchrone Standardeingaben und -ausgaben über Pipes zu implementieren

Normalerweise stoßen wir auf solche Anforderungen: Um ein komplexes Funktionsmodul über C oder andere Sprachen auf niedrigerer Ebene zu implementieren, müssen wir eine webbasierte Demo erstellen und Daten abfragen. Aufgrund der Leistungsfähigkeit und Einfachheit der Python-Sprache eignet sie sich sehr gut zum Erstellen von Demos. Die Funktionen des Flask-Frameworks und des Jinja2-Moduls bieten Python praktische Webentwicklungsfunktionen. Gleichzeitig kann Python problemlos mit Codes in anderen Sprachen interagieren. Daher wählen wir Python als Tool für die Demo-Entwicklung. Gehen Sie davon aus, dass das Modul, das wir aufrufen müssen (das die zugrunde liegenden Dienste bereitstellt), Daten in einer Schleife über die Standardeingabe liest und die Ergebnisse nach der Verarbeitung in die markierte Ausgabe schreibt. Dieses Szenario kommt in der Linux-Umgebung sehr häufig vor und basiert auf der leistungsstarken Umleitungsfunktion von Linux . Leider weist das zugrunde liegende Modul jedoch einen umfangreichen Initialisierungsprozess auf, sodass wir den untergeordneten Prozess, der das zugrunde liegende Modul aufruft, nicht für jede Abfrageanforderung erneut starten können. Die Lösung besteht darin, den untergeordneten Prozess nur einmal zu starten und dann für jede Anfrage über eine Pipe mit dem untergeordneten Prozess zu interagieren.

Das Unterprozessmodul von Python kann problemlos Unterprozesse generieren, ähnlich den Linux-Systemaufrufen fork und exec. Das Popen-Objekt des Unterprozessmoduls kann externe ausführbare Programme auf nicht blockierende Weise aufrufen. Daher verwenden wir das Poen-Objekt, um unsere Anforderungen zu erfüllen. Wenn wir Daten in die Standardeingabe stdin des Unterprozesses schreiben möchten, müssen wir beim Erstellen des Popen-Objekts den Parameter stdin als subprocess.PIPE angeben. Wenn wir Daten aus der Standardausgabe des Unterprozesses lesen müssen, müssen wir dies tun Beim Erstellen eines Popen-Objekts müssen Sie den Parameter stdout als subprocess.PIPE angeben. Schauen wir uns zunächst ein einfaches Beispiel an:

from subprocess import Popen, PIPE
p = Popen('less', stdin=PIPE, stdout=PIPE)
p.communicate('Line number %d.\n' % x)

Die Kommunikationsfunktion gibt ein Tupel (stdoutdata, stderrdata) zurück, das die Standardausgabe des untergeordneten Prozesses und die Ausgabedaten-Markierungsfehler enthält . Da jedoch die Kommunikationsfunktion des Popen-Objekts den übergeordneten Prozess blockiert und auch die Pipe schließt, kann jedes Popen-Objekt die Kommunikationsfunktion nur einmal aufrufen. Bei mehreren Anforderungen muss das Popen-Objekt neu generiert werden (Neuinitialisierung des untergeordneten Prozesses). die unsere Bedürfnisse nicht befriedigen können.

Daher können wir unsere Bedürfnisse nur erfüllen, indem wir Daten in die stdin- und stdout-Objekte des Popen-Objekts schreiben und lesen. Leider wird das Unterprozessmodul jedoch standardmäßig nur einmal ausgeführt und liest die Standardausgabe, wenn der Unterprozess beendet wird. Sowohl der Unterprozess als auch os.popen* erlauben nur eine einmalige Eingabe und Ausgabe, und die Ausgabe darf nur gelesen werden, wenn der Prozess beendet wird.

Nach einigen Recherchen habe ich herausgefunden, dass der Unterprozess über die Funktion fcntl verarbeitet werden kann Das fcntl-Modul Die Standardausgabe des Prozesses wird in einen nicht blockierenden Modus geändert, um unseren Zweck zu erreichen. Dieses Problem, das mich schon lange beschäftigt, wurde endlich perfekt gelöst. Der Code lautet wie folgt:

#!/usr/bin/python                                                                                                                                                      
# -*- coding: utf-8 -*-
# author: weisu.yxd@taobao.com
from subprocess import Popen, PIPE
import fcntl, os
import time
class Server(object):
  def __init__(self, args, server_env = None):
    if server_env:
      self.process = Popen(args, stdin=PIPE, stdout=PIPE, stderr=PIPE, env=server_env)
    else:
      self.process = Popen(args, stdin=PIPE, stdout=PIPE, stderr=PIPE)
    flags = fcntl.fcntl(self.process.stdout, fcntl.F_GETFL)
    fcntl.fcntl(self.process.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)
  def send(self, data, tail = '\n'):
    self.process.stdin.write(data + tail)
    self.process.stdin.flush()
  def recv(self, t=.1, e=1, tr=5, stderr=0):
    time.sleep(t)
    if tr < 1:
        tr = 1 
    x = time.time()+t
    r = &#39;&#39;
    pr = self.process.stdout
    if stderr:
      pr = self.process.stdout
    while time.time() < x or r:
        r = pr.read()
        if r is None:
            if e:
                raise Exception(message)
            else:
                break
        elif r:
            return r.rstrip()
        else:
            time.sleep(max((x-time.time())/tr, 0))
    return r.rstrip()
if __name__ == "__main__":
  ServerArgs = [&#39;/home/weisu.yxd/QP/trunk/bin/normalizer&#39;, &#39;/home/weisu.yxd/QP/trunk/conf/stopfile.txt&#39;]
  server = Server(ServerArgs)
  test_data = &#39;在云端&#39;, &#39;云梯&#39;, &#39;摩萨德&#39;, &#39;Alisa&#39;, &#39;iDB&#39;, &#39;阿里大数据&#39;
  for x in test_data:
    server.send(x)
    print x, server.recv()

Darüber hinaus müssen Sie beim Aufruf einiger externer Programme möglicherweise die entsprechenden Umgebungsvariablen wie folgt angeben:

  my_env = os.environ
  my_env["LD_LIBRARY_PATH"] = "/path/to/lib"
  server = server.Server(cmd, my_env)