thread_worker

Thread_worker

Verwenden Sie den Verbrauchermodus des Produzenten bequem mit Multi-Threading + -Tharnschaften, um den normalen One-Produzent mehrere Verbrauchermodi zu unterstützen

Installieren

pip install thread_worker

Arbeiten

Worker gewöhnliche Multi-Thread-Arbeit
PriorWorker vorrangiger Arbeiter
LimitWorker Current Limit Work beschränken

verwenden

Initialisierung sind die folgenden Parameter verfügbar

    def __init__ ( self , consumer_func , consumer_count , logger , block , timeout ):
        '''
        @params consumer_func consumer_func default None
        @params consumer_count Work quantity
        @params logger You can customize the logger. The default is logging
        @params block You can set whether the thread ends when the queue is empty 
                By default, the thread will end when the queue is empty and the thread task is completed
                You can set it to true to enable work to monitor tasks all the time
        @params timeout The timeout for obtaining data in the queue is 5S by default, that is, if the data is not obtained within 5S, it will end

        '''

Consumer_Func Consumer Function standardmäßig keine. Wenn hinzugefügt, wird davon ausgegangen, dass der Verbraucher zuerst gestartet wird und die Aufgabe generiert wird. Consumer_Count steuert, wie viele Verbraucher dort sind.
Logger soll die Protokollausgabe einstellen
Block soll steuern, ob es sich um den Blockierungsmodus handelt. Wenn auf True gesetzt, wird der Arbeits -Thread weiter ausgeführt, bis der Hauptprozess endet. Andernfalls enden die Arbeiten, wenn die Warteschlange leer ist und die Fadenaufgaben erledigt sind.
Timeout ist das Timeout, um Daten aus der Warteschlange zu erhalten. Das Standard -Timeout beträgt 5s. Wenn der Join wahr ist, wird die Arbeit wieder zu False führen und die aktuelle Arbeit beenden.

Es gibt zwei Nutzungsszenarien für das Hersteller- und Verbrauchermodell

Eine ist, zuerst den Verbraucher zu führen und ihn dann zu generieren. Es kann es kontinuierlich erzeugen und konsumieren. Es eignet sich für passive Agenten -Scanaufgaben oder ein Hauptprozess steuert die globale und generiert dann Aufgaben.

Eine soll alle Aufgaben gleichzeitig generieren und dem Verbraucher übergeben, um die Aufgabe auszuführen, die für die gleichzeitige Erstellung von Tests geeignet ist und sie dann ausführen kann.

Blockieren Sie Multi-Threaded-Aufgaben durch die Arbeit.is_end-Methode

1. Verbraucherfunktionen definieren
2. Beispiel eine Work
3. Zur Verbraucherfunktion durch Work Daten der Instanz put
4. Blockieren des Programms durch Work.is_end() Methode

Basisarbeiter

 from thread_worker import Worker
import requests
import time
def consumer ( iid ):
    url = "https://www.baidu.com/{0}" . format ( iid )
    resp = requests . get ( url = url )
    print ( resp . request . url )
# 不需要阻塞
w = Worker ( consumer , consumer_count = 1 , block = False )
for iid in range ( 10 ):
    w . put ( iid )
# 这里通过 is_end 方法来阻塞程序 
while not w . is_end ():
    time . sleep ( 3 )

Erstellen Sie eine Arbeit, die den Fluss einschränkt

Wie bei der Standardarbeit gibt es beim Erstellen einen zusätzlichen limit_time -Parameter. Durch Einstellen limit_time und consumer_count steuert sie, wie viele Arbeiten innerhalb einer Einheitszeit ausgeführt werden.
Die Standard limit_time beträgt 1s

 from thread_worker import LimitWorker
import requests
import time
def consumer ( iid ):
    url = "https://www.baidu.com/{0}" . format ( iid )
    resp = requests . get ( url = url )
    print ( resp . request . url )
# limit_time 是limit_time 秒内有 consumer_count个消费者
w = LimitWorker ( consumer , consumer_count = 1 , block = False , limit_time = 3 )
for iid in range ( 10 ):
    w . put ( iid )
# 这里通过 is_end 方法来阻塞程序 
while not w . is_end ():
    time . sleep ( 3 )

Die Ausgabe ist so. Alle 3 Sekunden wird nur eine Anfrage gesendet, dh die Frequenz wird kontrolliert.

 send: 2022-04-08 10:13:04 904000
https://www.baidu.com/0
send: 2022-04-08 10:13:07 904000
https://www.baidu.com/1
send: 2022-04-08 10:13:10 904000
https://www.baidu.com/2
send: 2022-04-08 10:13:13 904000
https://www.baidu.com/3
send: 2022-04-08 10:13:16 904000
https://www.baidu.com/4
send: 2022-04-08 10:13:19 904000
https://www.baidu.com/5
send: 2022-04-08 10:13:22 904000
https://www.baidu.com/6
send: 2022-04-08 10:13:25 904000
https://www.baidu.com/7
send: 2022-04-08 10:13:28 904000
https://www.baidu.com/8
send: 2022-04-08 10:13:31 904000
https://www.baidu.com/9

Führen Sie zuerst den Verbraucher durch und hören Sie sich die Warteschlange an und generieren Sie dann kontinuierlich Aufgaben

In diesem Szenario werden passive Agenten oder einige Hauptprozesse in Programmen verwendet, die lange Zeit ausgeführt werden. Der Unterschied besteht darin, dass die Methode der Arbeit.is_end () nicht erforderlich ist, um den Block zu blockieren oder den Block festzulegen. Der Standard ist wahr.

 from thread_worker import Worker
import requests
import time
def consumer ( iid ):
    url = "https://www.baidu.com/{0}" . format ( iid )
    resp = requests . get ( url = url )
    print ( resp . request . url )
# block默认就是True的
w = Worker ( consumer , consumer_count = 1 )
for iid in range ( 10 ):
    w . put ( iid )
# 手动阻塞
while True :
    pass