Python Language Nozioni di base sul multithreading


Esempio

Utilizzando il modulo di threading , è possibile avviare un nuovo thread di esecuzione creando un nuovo threading.Thread e assegnargli una funzione da eseguire:

import threading

def foo():
  print "Hello threading!"

my_thread = threading.Thread(target=foo)

Il parametro target riferimento alla funzione (o oggetto callable) da eseguire. Il thread non inizierà l'esecuzione finché non viene chiamato start sull'oggetto Thread .

Iniziare una discussione

my_thread.start() # prints 'Hello threading!'

Ora che my_thread è stato eseguito e terminato, richiamando start verrà RuntimeError un RuntimeError . Se si desidera eseguire il thread come daemon, passando il daemon=True kwarg o impostando my_thread.daemon su True prima di chiamare start() , il Thread avvia silenziosamente in background come daemon.

Partecipare a una discussione

Nei casi in cui dividi un grosso lavoro in più di uno piccolo e desideri eseguirli contemporaneamente, ma Thread.join() aspettare che finiscano tutti prima di continuare, Thread.join() è il metodo che stai cercando.

Ad esempio, supponiamo di voler scaricare diverse pagine di un sito Web e di compilarle in un'unica pagina. Faresti questo:

import requests
from threading import Thread
from queue import Queue

q = Queue(maxsize=20)
def put_page_to_q(page_num):
    q.put(requests.get('http://some-website.com/page_%s.html' % page_num)

def compile(q):
    # magic function that needs all pages before being able to be executed
    if not q.full():
        raise ValueError
    else:
        print("Done compiling!")

threads = []
for page_num in range(20):
     t = Thread(target=requests.get, args=(page_num,))
     t.start()
     threads.append(t)

# Next, join all threads to make sure all threads are done running before
# we continue. join() is a blocking call (unless specified otherwise using 
# the kwarg blocking=False when calling join)
for t in threads:
    t.join()

# Call compile() now, since all threads have completed
compile(q)

Uno sguardo più ravvicinato a come funziona join() può essere trovato qui .

Creare una classe thread personalizzata

Usando la classe threading.Thread possiamo sottoclasse la nuova classe Thread personalizzata. dobbiamo sovrascrivere il metodo run in una sottoclasse.

from threading import Thread
import time

class Sleepy(Thread):

    def run(self):
        time.sleep(5)
        print("Hello form Thread")

if __name__ == "__main__":
    t = Sleepy()
    t.start()      # start method automatic call Thread class run method.
    # print 'The main program continues to run in foreground.'
    t.join()
    print("The main program continues to run in the foreground.")