Explication du threading et des sous-processus Python

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

from urllib.request import urlopen
from time import perf_counter

def work(n):    
    with urlopen("https://www.google.com/#{n}") as f:
        contents = f.read(32)
    return contents

def run_pool(pool_type):
    with pool_type() as pool:
        start = perf_counter()
        results = pool.map(work, numbers)
    print ("Time:", perf_counter()-start)
    print ((_ for _ in results))    

if __name__ == '__main__':
    numbers = (x for x in range(1,16))
    
    # Run the task using a thread pool
    run_pool(ThreadPoolExecutor)
    
    # Run the task using a process pool
    run_pool(ProcessPoolExecutor)

Comment fonctionne le multitraitement Python

Dans l'exemple ci-dessus, le concurrent.futures Le module fournit des objets pool de haut niveau pour exécuter le travail dans les threads (ThreadPoolExecutor) et les processus (ProcessPoolExecutor). Les deux types de pools ont la même API, vous pouvez donc créer des fonctions qui fonctionnent de manière interchangeable avec les deux, comme le montre l'exemple.

Nous utilisons run_pool soumettre des instances de work fonction aux différents types de piscines. Par défaut, chaque instance de pool utilise un seul thread ou processus par cœur de processeur disponible. La création de pools entraîne une certaine surcharge, alors n'en faites pas trop. Si vous envisagez de traiter de nombreux travaux sur une longue période, créez d'abord le pool et ne vous en débarrassez pas avant d'avoir terminé. Avec le Executor objets, vous pouvez utiliser un gestionnaire de contexte pour créer et supprimer des pools (with/as).

pool.map() est la fonction que nous utilisons pour subdiviser le travail. Le pool.map() La fonction prend une fonction avec une liste d'arguments à appliquer à chaque instance de la fonction, divise le travail en morceaux (vous pouvez spécifier la taille du morceau mais la valeur par défaut est généralement correcte) et transmet chaque morceau à un thread ou un processus de travail.