Python Language Bases du multithreading


Exemple

En utilisant le module de threading , un nouveau thread d'exécution peut être démarré en créant un nouveau threading.Thread et en lui assignant une fonction à exécuter:

import threading

def foo():
  print "Hello threading!"

my_thread = threading.Thread(target=foo)

Le paramètre target référence à la fonction (ou à l'objet appelable) à exécuter. Le thread ne commencera pas l'exécution tant que l'objet Thread n'a pas start .

Commencer un fil

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

Maintenant que my_thread a été exécuté et terminé, l'appel start nouveau produira une RuntimeError . Si vous souhaitez exécuter votre thread en tant que démon, en passant le daemon=True kwarg ou en définissant my_thread.daemon sur True avant d'appeler start() , votre Thread s'exécute en arrière-plan en tant que démon.

Rejoindre un fil

Dans les cas où vous divisez un gros job en plusieurs petits et que vous souhaitez les exécuter simultanément, mais que vous devez attendre qu'ils soient tous terminés avant de continuer, Thread.join() est la méthode que vous recherchez.

Par exemple, supposons que vous souhaitiez télécharger plusieurs pages d'un site Web et les compiler en une seule page. Vous feriez ceci:

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)

Un aperçu plus précis de la manière dont fonctionne join() peut être trouvé ici .

Créer une classe de threads personnalisée

En utilisant la classe threading.Thread , on peut sous-classer la nouvelle classe de threads personnalisée. nous devons remplacer la méthode d' run dans une sous-classe.

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.")