Python Threading stdin/stdout

Ich habe eine Datei, die enthält eine Menge von Daten. Jede Zeile ist ein Datensatz. Und ich bin versucht zu tun, einige ETL-Arbeit gegen die ganze Datei. Jetzt bin ich mit standard-input zum Lesen der Daten Zeile für Zeile. Die kühle Sache über dieses ist, Ihr Skript könnte sehr flexibel sein, um die Integration mit anderen script-und shell-Befehle. Ich Schreibe das Ergebnis auf die Standardausgabe. Zum Beispiel.

$ cat input_file
line1 
line2
line3
line4
...

Meine aktuelle python-code sieht wie folgt aus - parse.py

import sys
for line in sys.stdin:
    result = ETL(line)    # ETL is some self defined function which takes a while to execute.
    print result

Den code unten ist, wie es funktioniert jetzt:

cat input_file | python parse.py > output_file

Ich habe mir das Threading-Modul von Python und ich Frage mich, ob das würde die Leistung drastisch verbessert, wenn ich das Modul.

Frage 1: Wie sollte ich planen die Quoten für jeden thread, warum?

...
counter = 0
buffer = []
for line in sys.stdin:
    buffer.append(line)
    if counter % 5 == 0:   # maybe assign 5 rows to each thread? if not, is there a rule of thumb to determine
        counter = 0
        thread = parser(buffer)
        buffer = []
        thread.start()

Question2: Mehrere Threads, vielleicht drucken Sie das Ergebnis wieder auf stdout zur gleichen Zeit, wie Sie zu organisieren und zu vermeiden, die situation da unten?

import threading
import time

class parser(threading.Thread):
    def __init__ (self, data_input):
        threading.Thread.__init__(self)
        self.data_input = data_input

    def run(self):
        for elem in self.data_input:
            time.sleep(3)
            print elem + 'Finished'

work = ['a', 'b', 'c', 'd', 'e', 'f']

thread1 = parser(['a', 'b'])  
thread2 = parser(['c', 'd'])
thread3 = parser(['e', 'f'])

thread1.start()
thread2.start()
thread3.start()

Die Ausgabe ist wirklich hässlich, wo eine Zeile enthält, die Ausgänge von zwei threads.

aFinished
cFinishedeFinished

bFinished
fFinished
dFinished

Könnten Sie den link "Threading-Modul von Python". Jedenfalls threading ist nicht eine gute Sache zu haben, beim Zugriff auf eine Datei, IMHO. Sie müssen definieren, was core zugreifen kann, was und Wann durch sperren und Semaphoren und das funktioniert. Wahrscheinlich würden Sie nicht eine große Leistungssteigerung, da die meisten die Arbeit, die I/O arbeiten, nicht die CPU die Arbeit.

InformationsquelleAutor B.Mr.W. | 2013-08-21

4

Nehmen Ihre zweite Frage zuerst, das ist, was Mutexe sind. Sie können den Reiniger Ausgabe, die Sie wollen, indem Sie eine Sperre zu koordinieren, unter den Parser und sicherzustellen, dass nur ein thread Zugriff auf den Ausgabe-stream, der während einer bestimmten Zeit:
```
class parser(threading.Thread):
    output_lock = threading.Lock()

    def __init__ (self, data_input):
        threading.Thread.__init__(self)
        self.data_input = data_input

    def run(self):
        for elem in self.data_input:
            time.sleep(3)
            with self.output_lock:
                print elem + 'Finished'
```
Bezüglich Ihrer ersten Frage, Anmerkung, dass es wahrscheinlich der Fall, dass multi-threading bieten Sie keinen nutzen für Ihre jeweiligen Arbeitsauslastung. Es hängt davon ab, ob die Arbeit, die Sie tun, jeden Eingang (Ihre ETL - Funktion) ist in Erster Linie CPU-bound oder IO-bound. Falls ersteres (was ich vermute, ist wahrscheinlich), threads werden nicht helfen, weil der global interpreter lock. In diesem Fall würden Sie wollen, um die multiprocessing - Modul zum verteilen der Arbeit auf mehrere Prozesse statt mehrere threads.

Aber Sie können die gleichen Ergebnisse mit einem einfacher zu implementieren, - workflow: teilen Sie die input-Datei in n Stücke (mit, z.B., der split Befehl); aufrufen der extract-transform-Skript separat auf jede Subdatei; dann verketten Sie die Ausgabe-Dateien.

Einen Fehler: "die Verwendung von standard-input zum Lesen der Daten Zeile für Zeile, weil es lädt nicht die gesamte Datei in den Speicher" um ein Missverständnis. Können Sie eine Datei Lesen und Zeile für Zeile innerhalb von Python durch, z.B., ersetzen sys.stdin mit einem file-Objekt in einem Konstrukt wie:
```
for line in sys.stdin:
```
Siehe auch die readline() - Methode der file-Objekte, und beachten Sie, dass read() können als parameter die maximale Anzahl der zu lesenden bytes.

Viele tolle Sachen in deinem post, Alp. Ich bin sehr daran interessiert, Ihre Kommentare CPU-gebunden/IO-bound. Ich Frage mich, haben Sie einen Weg, um zu bestimmen, wie viel Zeit und Ressourcen getroffen werden, die von CPU/IO? btw, Sie Grund, dass ich mich mit stdIO ist, weil Sie könnte integrieren Sie Ihr Skript mit dem Shell-Befehl das macht es so viel flexibler und bequemer. Danke für die Korrektur über die "Memory midsunderstanding'.

InformationsquelleAutor Alp
0

Ob threading wird hilfreich sein, Sie ist stark abhängig von Ihrer situation. Insbesondere, wenn Ihr ETL() Funktion beinhaltet eine Menge Zugriff auf die Festplatte, dann einfädeln würden, dürfte Ihnen ziemlich erhebliche Verbesserung der Geschwindigkeit.

In der Antwort zu Ihrer ersten Frage, ich habe immer gefunden, dass es gerade hängt. Es gibt eine Menge Faktoren spielen bei der Bestimmung der idealen Anzahl von threads, und viele von Ihnen sind Programm-abhängig. Wenn du tust, viel Zugriff auf die Festplatte (das ist ziemlich langsam), zum Beispiel, dann werden Sie wollen mehr threads zu nutzen, die Ausfallzeiten während der Wartezeit für Zugriff auf die Festplatte. Wenn das Programm die CPU-gebunden, obwohl, Tonnen von threads, die vielleicht nicht super hilfreich. So, während es vielleicht möglich ist, zu analysieren alle Faktoren, die eine ideale Anzahl der threads an, es ist in der Regel viel schneller zu machen, eine erste Vermutung, und passen Sie dann von dort.

Genauer gesagt, obwohl, ist die Zuweisung einer bestimmten Anzahl von Zeilen zu jedem thread ist wohl nicht der beste Weg zu gehen über divvying auf der Arbeit. Denken Sie zum Beispiel, wenn eine Zeile nimmt eine besonders lange Zeit zu verarbeiten. Am besten wäre es, wenn ein thread könnte die Arbeit Weg an, dass eine Zeile und die anderen threads konnte jeder noch ein paar Zeilen mehr in der Zwischenzeit. Der beste Weg, um dies zu umgehen, ist die Verwendung einer Warteschlange. Wenn Sie schieben Sie jede Zeile in eine Warteschlange, dann kann jeder thread, ziehen Sie eine Linie aus der Warteschlange, damit umgehen, und wiederholen Sie, bis die Warteschlange leer ist. Auf diese Weise, die Arbeit wird verteilt, so dass kein thread jemals ohne Arbeit zu tun (bis auf das Ende natürlich).

Nun, ist die zweite Frage. Du hast auf jeden Fall Recht, dass das schreiben auf stdout aus mehreren threads auf einmal nicht die ideale Lösung. Im Idealfall würden Sie die Dinge so anzuordnen, dass das schreiben auf stdout passiert in nur einem Ort. Eine große Weise, das zu tun, ist die Verwendung einer Warteschlange. Wenn Sie in jeden thread schreiben Ihre Ausgabe auf eine freigegebene Warteschlange, dann können Sie spawn-einen zusätzlichen thread, dessen einzige Aufgabe ist, ziehen Sie die Elemente aus, die Warteschlange und drucken Sie Sie auf stdout aus. Durch die Beschränkung der Druck auf nur eine threading, Sie vermeiden die Probleme, die inhärent in mehrere threads versuchen, zu drucken, auf einmal.

InformationsquelleAutor mculhane

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.