La différence entre le pool de threads Python et le multithreading

La différence entre le pool de threads python et le multithread : 1. Les threads voyagent sous le processus ; 2. Les threads voyagent sous le processus ; 3. Un processus peut contenir plusieurs threads ; 4. Les données sont difficiles à partager entre différents processus ; . Processus Consomme plus de ressources informatiques que de threads.

1. Threads et multi-threads

Processus : Lorsqu'un programme est exécuté, il peut être appelé un processus, qui inclut le programme en cours d'exécution ainsi que la mémoire et les ressources système utilisées par le programme. plusieurs threads Composé de.

Thread : Un thread est un flux d'exécution dans un programme. Chaque thread a son propre registre privé et la zone de code est partagée. Différents threads peuvent exécuter la même fonction.

Multi-threading : Le multithreading signifie qu'un programme contient plusieurs flux d'exécution, c'est-à-dire qu'un programme peut exécuter plusieurs threads différents en même temps pour effectuer différentes tâches, permettant à un seul programme de créer plusieurs threads d'exécution parallèles pour accomplir leurs tâches respectives.

Le plus grand avantage du multi-threading : Améliorer l'utilisation du processeur (particulièrement adapté aux programmes gourmands en E/S, l'amélioration de la vitesse est particulièrement évidente)

La différence entre les processus et les threads :

Une métaphore simple : processus = train, thread = chariot

Les threads voyagent sous le processus (un simple wagon ne peut pas fonctionner)

Un processus peut contenir plusieurs threads (un train peut avoir plusieurs wagons)

Il est difficile de partager des données entre différents processus (c'est difficile pour les passagers d'un train Changement vers un autre train, comme un transfert de gare)

Les données sont facilement partagées entre différents threads dans le même processus (il est facile de passer du wagon A au wagon B)

Les processus consomment plus de ressources informatiques que les threads (en utilisant plusieurs trains Trains consomme plus de ressources que plusieurs wagons)

Les processus ne s'affecteront pas. Si un thread raccroche, l'ensemble du processus raccrochera (un train n'affectera pas un autre train, mais si le wagon du milieu d'un train, un incendie affectera tous les wagons)

Le processus peut être étendu à plusieurs machines, et le processus convient tout au plus au multicœur (différents trains peuvent circuler sur plusieurs voies, et les wagons du même train ne peuvent pas être sur des voies différentes)

Processus utilisation L'adresse mémoire peut être verrouillée, c'est-à-dire que lorsqu'un thread utilise de la mémoire partagée, les autres threads doivent attendre qu'elle se termine avant de pouvoir utiliser cette partie de la mémoire. (Par exemple, les toilettes dans le train) - "Mutex lock"

L'adresse mémoire utilisée par le processus peut limiter l'utilisation (par exemple, un restaurant dans le train, seul un nombre maximum de personnes est autorisé à entrer, si il est plein, il faut attendre à la porte que quelqu'un sorte Pour entrer) - "Sémaphore"

2. La classe threading du multi-threading

La classe threading est le module multi-threading le plus couramment utilisé. de création d'un fil est la suivante :

threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, 
daemon=None)

group : La valeur par défaut est Aucun

target : Pour Le nom de la fonction exécutée, n'oubliez pas de ne pas inclure de parenthèses de fonction

name : nom du fil, par défaut 'Thread-N. ' form.

args : tuple de paramètres de l'objet appelable passé dans le paramètre target.

kwargs : Dictionnaire de paramètres de mots clés de l'objet appelable passé dans le paramètre target.

daemon : attribut du mode Guardian, la valeur par défaut est None.

Méthodes importantes de l'objet thread :

start() : démarre le thread. Cela fera que la méthode run () est appelée dans un thread indépendant.

run() : cette méthode représente l'activité du thread

join(timeout=. Aucun) : Laissez le thread appelant actuel attendre la fin du thread

Démon : représente si le thread est un thread démon, vrai ou faux.

Créez une instance multithread :

import random
import threading
import time
def awesome_function(name):
wait_time = random.randint(1, 10)
print('current thread name is :{0} and wait {1} s'.format(name, 
wait_time))
time.sleep(wait_time)
print('thread {} finished.'.format(name))
if __name__ == '__main__':
for i in range(0, 3):
t = threading.Thread(target=awesome_function, args=(i,))
t.start()

Vous pouvez d'abord y jeter un œil. aux résultats d'exécution que j'ai enregistrés :

L'exemple ci-dessus démarre 3 threads, et 3 threads exécutent des tâches simultanément. Terminez la tâche en premier. Le thread (celui avec le temps de sommeil le plus court) affiche le résultat en premier.

Trois. -classe de pool de threads utilisée ThreadPoolExecutor

Le démarrage d'un nouveau thread est très coûteux car cela implique une interaction avec le système d'exploitation. Dans ce cas, l'utilisation de pools de threads peut considérablement améliorer les performances du programme, en particulier lorsque le programme doit créer un grand nombre de threads avec. durées de vie très courtes, vous devriez envisager d'utiliser des pools de threads.

Le pool de threads crée un grand nombre de threads inactifs lorsque le système démarre, et le programme Tant qu'une fonction est soumise au pool de threads, le pool de threads démarrera un processus inactif. thread pour l'exécuter. Lorsque la fonction se termine, le thread ne mourra pas, mais reviendra à nouveau dans le pool de threads et deviendra inactif, en attente. En même temps, l'utilisation du pool de threads peut contrôler efficacement le nombre de threads simultanés. dans le système. Lorsque le système contient un grand nombre de threads simultanés, cela entraînera une forte baisse des performances du système et même un crash de l'interpréteur Python, et le paramètre nombre maximal de threads peut contrôler le nombre de threads simultanés. dans le système pour ne pas dépasser ce nombre.

Le pool de threads actuellement utilisé est le ThreadPoolExecutor dans le module concurrent.futures :

import random
import time
from concurrent.futures import ThreadPoolExecutor
def awesome_function(name):
wait_time = random.randint(1, 10)
print('current thread name is :{0} and wait {1} s'.format(name, 
wait_time))
time.sleep(wait_time)
print('thread {} finished.'.format(name))
if __name__ == '__main__':
with ThreadPoolExecutor(max_workers=3) as t:
for i in range(0, 3):
t.submit(awesome_function, i)

Les résultats en cours d'exécution sont enregistrés comme suit :

Créez un pool de threads avec une capacité maximale de 3 Objet pool de threads, soumettez la fonction exécutée au pool de threads via submit S'il y a un thread dans le pool de threads (thread). 2) Une fois l'exécution terminée, le thread inactif (thread 3) est placé dans le pool, et ainsi de suite, jusqu'à ce que tous les threads soient terminés, le programme se termine.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!