Python: Threading bestimmte Anzahl von Malen

Question

Ich habe den folgenden Code, der threading verwendet und druckt die aktuelle Anzahl.

import threading 

count = 0 
def worker(): 
    """thread worker function""" 
    global count 
    count += 1 
    print(count) 

threads = [] 
for i in range(5): 
    t = threading.Thread(target=worker) 
    threads.append(t) 
    t.start() 

Es ist derzeit auf 5 Threads eingestellt. Wie kann ich die Threads so lange ausführen lassen, bis sie ein bestimmtes # erreicht haben. d.h. bei 5 Threads laufen, bis worker() 100 Mal abgelaufen ist.

Answer 1

machen Sie einfach eine while-Schleife, aber schützen Sie Ihren Zähler und Ihren Test mit einer Sperre, sonst wird der getestete Wert von dem Wert abweichen, den Sie gerade erhöht haben.

Ich habe die Thread-ID hinzugefügt, so dass wir sehen, welcher Thread den Zähler tatsächlich erhöht.

Auch: zuerst prüfen, danach erhöhen.

Und warten Sie auf die Threads am Ende.

import threading 

lck = threading.Lock() 

count = 0 
def worker(): 
    global count 
    """thread worker function""" 
    while True: 
     lck.acquire() 
     if count==100: 
      lck.release() 
      break 
     count += 1 
     print(threading.current_thread() ,count) 
     lck.release() 

threads = [] 
for i in range(5): 
    t = threading.Thread(target=worker) 
    threads.append(t) 
    t.start() 

for t in threads: 
    t.join() 

Ergebnis:

(<Thread(Thread-1, started 5868)>, 1) 
(<Thread(Thread-2, started 7152)>, 2) 
(<Thread(Thread-3, started 6348)>, 3) 
(<Thread(Thread-4, started 6056)>, 4) 
(<Thread(Thread-1, started 5868)>, 5) 
(<Thread(Thread-5, started 5748)>, 6) 
(<Thread(Thread-2, started 7152)>, 7) 
(<Thread(Thread-3, started 6348)>, 8) 
(<Thread(Thread-4, started 6056)>, 9) 
(<Thread(Thread-1, started 5868)>, 10) 
(<Thread(Thread-5, started 5748)>, 11) 
(<Thread(Thread-2, started 7152)>, 12) 
(<Thread(Thread-3, started 6348)>, 13) 
(<Thread(Thread-4, started 6056)>, 14) 
(<Thread(Thread-1, started 5868)>, 15) 
(<Thread(Thread-5, started 5748)>, 16) 
(<Thread(Thread-2, started 7152)>, 17) 
(<Thread(Thread-3, started 6348)>, 18) 
(<Thread(Thread-4, started 6056)>, 19) 
(<Thread(Thread-1, started 5868)>, 20) 
(<Thread(Thread-5, started 5748)>, 21) 
(<Thread(Thread-2, started 7152)>, 22) 
(<Thread(Thread-3, started 6348)>, 23) 
(<Thread(Thread-4, started 6056)>, 24) 
(<Thread(Thread-1, started 5868)>, 25) 
(<Thread(Thread-5, started 5748)>, 26) 
(<Thread(Thread-2, started 7152)>, 27) 
(<Thread(Thread-3, started 6348)>, 28) 
(<Thread(Thread-4, started 6056)>, 29) 
(<Thread(Thread-1, started 5868)>, 30) 
(<Thread(Thread-5, started 5748)>, 31) 
(<Thread(Thread-2, started 7152)>, 32) 
(<Thread(Thread-3, started 6348)>, 33) 
(<Thread(Thread-4, started 6056)>, 34) 
(<Thread(Thread-1, started 5868)>, 35) 
(<Thread(Thread-5, started 5748)>, 36) 
(<Thread(Thread-2, started 7152)>, 37) 
(<Thread(Thread-3, started 6348)>, 38) 
(<Thread(Thread-4, started 6056)>, 39) 
(<Thread(Thread-1, started 5868)>, 40) 
(<Thread(Thread-5, started 5748)>, 41) 
(<Thread(Thread-2, started 7152)>, 42) 
(<Thread(Thread-3, started 6348)>, 43) 
(<Thread(Thread-4, started 6056)>, 44) 
(<Thread(Thread-1, started 5868)>, 45) 
(<Thread(Thread-5, started 5748)>, 46) 
(<Thread(Thread-2, started 7152)>, 47) 
(<Thread(Thread-3, started 6348)>, 48) 
(<Thread(Thread-4, started 6056)>, 49) 
(<Thread(Thread-1, started 5868)>, 50) 
(<Thread(Thread-5, started 5748)>, 51) 
(<Thread(Thread-2, started 7152)>, 52) 
(<Thread(Thread-3, started 6348)>, 53) 
(<Thread(Thread-4, started 6056)>, 54) 
(<Thread(Thread-1, started 5868)>, 55) 
(<Thread(Thread-5, started 5748)>, 56) 
(<Thread(Thread-2, started 7152)>, 57) 
(<Thread(Thread-3, started 6348)>, 58) 
(<Thread(Thread-4, started 6056)>, 59) 
(<Thread(Thread-1, started 5868)>, 60) 
(<Thread(Thread-5, started 5748)>, 61) 
(<Thread(Thread-2, started 7152)>, 62) 
(<Thread(Thread-3, started 6348)>, 63) 
(<Thread(Thread-4, started 6056)>, 64) 
(<Thread(Thread-1, started 5868)>, 65) 
(<Thread(Thread-5, started 5748)>, 66) 
(<Thread(Thread-2, started 7152)>, 67) 
(<Thread(Thread-3, started 6348)>, 68) 
(<Thread(Thread-4, started 6056)>, 69) 
(<Thread(Thread-1, started 5868)>, 70) 
(<Thread(Thread-5, started 5748)>, 71) 
(<Thread(Thread-2, started 7152)>, 72) 
(<Thread(Thread-3, started 6348)>, 73) 
(<Thread(Thread-4, started 6056)>, 74) 
(<Thread(Thread-1, started 5868)>, 75) 
(<Thread(Thread-5, started 5748)>, 76) 
(<Thread(Thread-2, started 7152)>, 77) 
(<Thread(Thread-3, started 6348)>, 78) 
(<Thread(Thread-4, started 6056)>, 79) 
(<Thread(Thread-1, started 5868)>, 80) 
(<Thread(Thread-5, started 5748)>, 81) 
(<Thread(Thread-2, started 7152)>, 82) 
(<Thread(Thread-3, started 6348)>, 83) 
(<Thread(Thread-4, started 6056)>, 84) 
(<Thread(Thread-1, started 5868)>, 85) 
(<Thread(Thread-5, started 5748)>, 86) 
(<Thread(Thread-2, started 7152)>, 87) 
(<Thread(Thread-3, started 6348)>, 88) 
(<Thread(Thread-4, started 6056)>, 89) 
(<Thread(Thread-1, started 5868)>, 90) 
(<Thread(Thread-5, started 5748)>, 91) 
(<Thread(Thread-2, started 7152)>, 92) 
(<Thread(Thread-3, started 6348)>, 93) 
(<Thread(Thread-4, started 6056)>, 94) 
(<Thread(Thread-1, started 5868)>, 95) 
(<Thread(Thread-5, started 5748)>, 96) 
(<Thread(Thread-2, started 7152)>, 97) 
(<Thread(Thread-3, started 6348)>, 98) 
(<Thread(Thread-4, started 6056)>, 99) 
(<Thread(Thread-1, started 5868)>, 100) 

Answer 2

Schleife es, natürlich.

lock = threading.Lock() 
count = 0 
def worker(): 
    """thread worker function""" 
    global count 
    while True: 
     with lock: 
      if count >= 100: break 
      count += 1 
      print(count) 

Beachten Sie den geschützten Zugriff auf count mit threading.Lock; verlassen auf GIL ist skizzenhaft.

Answer 3

Um ehrlich zu sein, wenn Sie so etwas wollen, bedeutet es, dass Sie in die falsche Richtung gehen. Da dieser Code stateful und stateful Verarbeitung ist, ist weit weg von der realen parallelen Ausführung. Auch wenn Sie Code in Python parallel ausführen möchten, müssen Sie multiprocessing Modul verwenden.

Also, im Grunde, wenn Sie Ziel 100 Mal insgesamt zu kreuzen ist, ist es besser, den Code in staatenlos Art und Weise neu zu schreiben:

import multiprocessing as mp 

def worker_1(x): 
    for i in range(x) 
     print i 

def worker_2(y): 
    print y 

if __name__ == '__main__': 
    p = mp.Pool(5) 

    for x in p.pool(worker_1, [25, 25, 25, 25]): 
    // process result 
    pass 

    for y in p.pool(worker_2, range(100)): 
    // process result 
    pass