Ich habe versucht, eine Bibliothek (Common Thread) zu verwenden, die die Verwendung des Python-Threading-Pakets vereinfacht

Ich habe versucht, eine Bibliothek (Common Thread) zu verwenden, die die Verwendung des Python-Threading-Pakets vereinfacht. https://pypi.org/project/commonthread/ Es ist genauer zu versuchen, es zu verwenden oder es zu machen.

Wie installiert man

So installieren Sie das Commonthread-Paket

pip install -U commonthread

Zu installierende Klassen

• class CommonThreadLogger
• class CommonThread(threading.Thread)
• class WorkerThread(CommonThread)

Erste Probe (01.py)

01.py

from commonthread import *


# source https://techacademy.jp/magazine/28155
def fibonacci_worker(th: WorkerThread, n: int):
    if n <= 2:
        return 1
    else:
        return fibonacci_worker(th, n - 2) + fibonacci_worker(th, n - 1)


thread = WorkerThread(fibonacci_worker, 36)
thread.name = 'tfib'
thread.start()
success = thread.join(timeout=0.5)
print('success={}'.format(success))
success = thread.join()
print('success={}'.format(success))
print('result={}'.format(thread.result))
print('elapsed={}'.format(thread.elapsed))
print(thread)

01.py Ausführungsergebnis

success=False
success=True
result=14930352
elapsed=3.688599109649658
WorkerThread(name=tfib, result=14930352, elapsed=3.688599109649658, args=(36,), kwargs={}, params={})

Erklärung (01.py)

• Eingeführt von der WorkerThread-Klasse, die von der in diesem Paket enthaltenen CommonThread-Klasse erbt. Wie im Code "thread = WorkerThread (fibonacci_worker, 36)" ist das erste Argument des WorkerThread-Konstruktors der Name der Worker-Funktion. Das zweite und nachfolgende Argument sind die Argumente, die an die Worker-Funktion übergeben werden. Sie können so viele übergeben, wie Sie möchten, solange sie mit der Anzahl der Worker-Funktionsargumente übereinstimmen.
• Das erste Argument der Worker-Funktion verwendet ein WorkerThread-Objekt wie im Code "def fibonacci_worker (th: WorkerThread, n: int)". Sie müssen dieses Argument erhalten, aber Sie müssen es nicht verwenden.
• Nach thread.join () drucke ich thread.result und thread.elapsed. Der von der Worker-Funktion fibonacci_worker zurückgegebene Wert wird automatisch im Ergebniselement des WorkerThread-Objekts gespeichert. Zusätzlich wird die verstrichene Zeit, die zum Ausführen der Worker-Funktion fibonacci_worker benötigt wird, im verstrichenen Element gespeichert.
• CommonThread und seine untergeordneten Klassen zeigen Namen, Ergebnisse, verstrichene Werte usw. an, wenn sie als "print (thread)" gedruckt werden. (Zum Debuggen)

Manchmal möchte ich einen Rückgabewert von einer Worker-Funktion zurückgeben, daher ist er für diesen Zweck optimiert.

Klassenbasiertes Thread-Beispiel (02.py)

02.py

from commonthread import *


# source https://techacademy.jp/magazine/28155
class FibonacciThread(CommonThread):

    def entry(self, n: int):
        if n <= 2:
            return 1
        else:
            return self.entry(n - 2) + self.entry(n - 1)


thread = FibonacciThread(36)
thread.name = 'tfib'
thread.start()
thread.join()
print('result={}'.format(thread.result))
print('elapsed={}'.format(thread.elapsed))
print(thread)

02.py Ausführungsergebnis

result=14930352
elapsed=4.399198055267334
FibonacciThread(name=tfib, result=14930352, elapsed=4.399198055267334, args=(36,), kwargs={}, params={})

Kommentar (02.py)

• Um einen klassenbasierten Thread (anstelle eines Worker-Funktions-basierten Threads) wie in class FibonacciThread (CommonThread) zu definieren, erweitern Sie die CommonThread-Klasse.
• Der Thread-Eintrag ist "entry (self ...)" anstelle von "run (self)". Dieser Thread, der die Fibonacci-Zahl berechnet, benötigt nur ein ganzzahliges Argument, also "def entry (self, n: int)". Sie können eine Eingabemethode mit einer beliebigen Anzahl von Argumenten verwenden, ohne sich mit dem Konstruktor einer Klasse herumschlagen zu müssen, die von CommonThread erbt. Wenn es sich um einen einfachen Prozess handelt, müssen Sie keine Konstruktordefinition erstellen, was nützlich ist.
• Davon abgesehen ist es fast dasselbe wie 01.py.

Beispiel eines klassenbasierten Threads, der Konstrukte definiert (03.py)

03.py

from commonthread import *


class AddThread(CommonThread):

    def __init__(self, x: int, y: int):
        CommonThread.__init__(self)
        self.x = x
        self.y = y

    def entry(self):
        time.sleep(2.0)
        return self.x + self.y


thread = AddThread(11, 22)
thread.start()
thread.join()
print('result={}'.format(thread.result))
print('elapsed={}'.format(thread.elapsed))
print(thread)

03.py Ausführungsergebnis

result=33
elapsed=2.0015878677368164
AddThread(name=Thread-1, result=33, elapsed=2.0015878677368164, args=(), kwargs={}, params={})

Kommentar (03.py)

• Im Fall von "Klasse AddThread (CommonThread)" wird der Konstruktor als "def init __ (self, x: int, y: int)" definiert, um die Argumente x und y zu akzeptieren. Wenn Sie also "init" in einer untergeordneten Klasse von CommonThread definieren, müssen Sie "CommonThread . init__ (self)" als erste Ausführungszeile schreiben. Das ist wie ein Zauber.
• Dann ist der Einstiegspunkt für die Thread-Ausführung "def entry (self)", und andere Argumente als das Thread-Objekt selbst werden nicht akzeptiert. Speichern Sie daher die Argumente in den Mitgliedern von self.x und slef.y im Konstruktor.

Beispiel für die Verknüpfung mit allen Threads derselben Klasse (04.py)

04.py

from commonthread import *


lg = CommonThreadLogger()
lg.setup_basic()


class ShortThread(CommonThread):

    def entry(self, duration):
        lg.debug('start')
        time.sleep(duration)
        lg.debug('end')
        return 'finished'


class LongThread(CommonThread):

    def entry(self, duration):
        lg.debug('start')
        time.sleep(duration)
        lg.debug('end')
        return 'finished'


lg.debug('start')

sth1 = ShortThread(1.0); sth1.name = 'sth1'
sth2 = ShortThread(1.5); sth2.name = 'sth2'

lth1 = LongThread(5.0); lth1.name = 'lth1'
lth2 = LongThread(6.0); lth2.name = 'lth2'

sth1.start()
sth2.start()
lth1.start()
lth2.start()

lg.debug(CommonThread.list_alive())

CommonThread.join_all(type=ShortThread)

lg.debug(CommonThread.list_alive())

CommonThread.join_all()

lg.debug(CommonThread.list_alive())

04.py Ausführungsergebnis

MainThread: start
sth1: start
sth2: start
lth1: start
lth2: start
MainThread: [ShortThread(name=sth1, result=None, elapsed=0.0, args=(1.0,), kwargs={}, params={}), ShortThread(name=sth2, result=None, elapsed=0.0, args=(1.5,), kwargs={}, params={}), LongThread(name=lth1, result=None, elapsed=0.0, args=(5.0,), kwargs={}, params={}), LongThread(name=lth2, result=None, elapsed=0.0, args=(6.0,), kwargs={}, params={})]
sth1: end
sth2: end
MainThread: [LongThread(name=lth1, result=None, elapsed=0.0, args=(5.0,), kwargs={}, params={}), LongThread(name=lth2, result=None, elapsed=0.0, args=(6.0,), kwargs={}, params={})]
lth1: end
lth2: end
MainThread: []

Kommentar (04.py)

• In diesem Beispiel wird zum ersten Mal die Protokollausgabe (zum Debuggen) verwendet. Nach dem Setzen von "lg = CommonThreadLogger ()" aktiviert "lg.setup_basic ()" die Debug-Protokollierung. Kommentieren Sie die Zeile lg.setup_basic () aus, wenn Sie nicht mehr debuggen müssen.
• Wenn Sie nach dem Ausführen von "lg.setup_basic ()" "lg.debug (~)" ausführen, wird als Standardfehler ein Protokoll mit "thread name:" am Anfang der Nachricht ausgegeben.
• Definiert einen LongThread, der von CommonThread erbt, sowie einen ShortThread, der von der CommonThread-Klasse erbt. Die Definitionen sind für beide gleich. Durch Anpassen der Wartezeit an die Argumentdauer wird ShortThread früher beendet.
• CommonThread.join_all (type = ShortThread) verbindet alle ShortThread-Instanzen und wartet darauf, dass sie beendet werden.
• CommonThread.join_all () verbindet alle CommonThread-Instanzen (einschließlich LongThread) und wartet, bis sie beendet sind.
• CommonThread.list_alive () gibt eine Liste aller aktiven (nicht abgeschlossenen) CommonThread-Objekte zurück.
• CommonThread.list_alive (type = ShortThread) gibt eine Liste aller aktiven (nicht abgeschlossenen) ShortThread-Objekte zurück.
• Obwohl nicht im Beispielcode enthalten, können Sie "CommonThread.are_alive ()" verwenden, um festzustellen, ob noch CommonThread aktiv ist. Wenn Sie "CommonThread.are_alive (type = ShortThread)" angeben, können Sie nur ShortThread überprüfen.

Schließlich

Die Funktionen, die dieses Mal nicht eingeführt werden konnten, sind:

• In CommonThread und WorkerThread bereitgestellte Funktionen für die Eingabe- / Ausgabewarteschlange
• Argumentanalysefunktion unter Verwendung der Befehlszeilenargumentanalysebibliothek argparse
• Verwendung des in CommonThread und WorkerThread bereitgestellten params-Elements Und so weiter. Ich möchte es in einem anderen Artikel vorstellen.