L'unité de base du système de processus pour l'allocation des ressources et la planification
L'unité de base de la planification et de la répartition indépendantes du système de threads est la plus petite unité de planification du processeur (la plus petite unité de flux d'exécution de programme)
La commutation de processus nécessite le plus de ressources et la plus faible efficacité
Le changement de thread nécessite des ressources médiocres et une efficacité médiocre (bien sûr sans tenir compte de GIL)
Les ressources des tâches de commutation de coroutine sont petites et efficaces, et les coroutines sont également appelées microtreads
En fonction du nombre de cœurs de processeur, plusieurs processus et plusieurs threads peuvent être parallèles, mais la coroutine est dans un thread, elle est donc simultanée.
Concurrence: lorsque plusieurs threads sont en cours d'exécution, si le système n'a qu'un seul processeur, il sera raisonnablement alloué à plusieurs threads pour effectuer des tâches, effectuer une multi-allocation plus rapide, une exécution lente sans allocation.
Parallèle: lorsque le système a plusieurs CPU, les threads seront alloués à différentes CPU sans préempter les ressources les uns des autres et peuvent être exécutés simultanément.
La plus grande différence entre la simultanéité et le parallélisme est de savoir si elles sont simultanées.
Multi-processus: exécutez simultanément plusieurs tâches différentes dans le système
Multithreading: effectuez plusieurs tâches différentes simultanément dans un seul programme
La différence
Un programme a au moins un processus, un processus a au moins un thread
Les processus ne partagent pas de variables globales, les threads peuvent partager des variables globales
Le thread lui-même ne possède pas de ressources système, il ne dispose que d'un petit nombre de ressources essentielles au fonctionnement, mais il peut être partagé avec d'autres threads appartenant au même processus
Multithreading (variables globales partagées)
de filetage import fil du
temps d'importation
def work1 (nums):
nums.append (44)
print ("---- in work1 ---", nums)
def work2 (nums):
# Délai pour s'assurer que les éléments du thread t1 sont terminés
time.sleep (1)
print ("---- in work2 ---", nums)
g_nums = [11,22,33]
t1 = Thread (target = work1, args = (g_nums,))
t1.start ()
t2 = Thread (target = work2, args = (g_nums,))
t2.start ()
Conclusion
Le partage de variables globales sur tous les threads d'un même thread est pratique pour que plusieurs threads partagent des données, mais si vous modifiez des variables globales provoquera la confusion entre plusieurs threads (c'est-à-dire que les threads ne sont pas sûrs)
Si plusieurs threads opèrent sur une variable globale en même temps, il y aura des problèmes de concurrence entre les ressources et le résultat des données sera incorrect.
Mutex
Objectif : lorsque plusieurs threads modifient presque simultanément certaines données partagées, un contrôle synchrone est requis
Avantages : garantir qu'un morceau de code critique ne peut être entièrement exécuté par un thread que du début à la fin
Inconvénients : empêche l'exécution simultanée de plusieurs threads, une certaine section de code qui contient des verrous ne peut être exécutée qu'en mode mono-thread, l'efficacité est considérablement réduite, car il peut y avoir plusieurs verrous, différents threads détiennent différents verrous, et Lorsque la vue acquiert le verrou détenu par l'autre partie, cela peut entraîner un blocage
# Créer un verrou
mutex = threading.Lock ()
# Verrouiller
mutex.acquire ()
# Relâchez
mutex.release ()
Évitez l'impasse
1. Essayez de l'éviter lors de la conception du programme (algorithme du banquier)
2. Ajouter un délai d'attente
Processus
Une façon de créer un processus:
import time from multiprocessing import Process def test (): "" "Le code exécuté séparément par le processus enfant" "" tandis que True: print ('---- test ----') time.sleep (1) # veille pendant une seconde Bell si __name__ == '__main__': p = Processus (cible = test) # en passant le nom de la fonction à la cible du processus spécifiera une référence à la fonction p.start () # démarrer le processus est créé lorsque cette phrase est exécutée Un processus # Le processus principal exécute le code tandis que True: print ('---- main ----') time.sleep (1)
Résumé:
1. En créant un processus supplémentaire, vous pouvez réaliser un processus multitâche en utilisant un processus pour réaliser le multitâche:
2. Créez un objet Process et spécifiez une référence de fonction par cible lors de la création
3. Lorsque start est appelé, il crée en fait un processus enfant
Méthodes courantes des objets d'instance créés par Process:
1.start (): démarrer une instance de sous-processus (créer un sous-processus)
2. is_live (): détermine si le processus enfant est toujours vivant
3.join ([timeout]): s'il faut attendre la fin de l'exécution du processus enfant, ou combien de secondes attendre
terminate (): que la tâche soit terminée ou non, arrêtez immédiatement le processus enfant
La deuxième façon de créer un processus:
import time
from multiprocessing import Process
# 方法二：
class MyProcess(Process):
def run(self):
while True:
print('----1----')
time.sleep(1)
if __name__ == '__main__':
p = MyProcess() # 创建一个MyProcess的对象
# 当执行到这一句话的时候 会调用p.start()方法，p会先去父类中寻找start(),然后再Process的start方法中调用run方法
p.start()
while True:
print('----main----')
time.sleep(1)
à partir de l'importation multiprocessus Processus à
partir de l'heure importation
test def sommeil (nom, âge, ** kwargs):
pour i dans la plage (10):
imprimer ('nom =% s, âge =% d'% (nom, âge))
imprimer ( kwargs)
sleep (0.2)
if __name__ == '__main__':
p = Process (target = test, args = ('小红', 18), kwargs = {'m': 20})
p.start ()
sleep ( 1)
p.terminate () # Que la tâche soit terminée ou non, terminez immédiatement le processus enfant
p.join () # json () attendra la fin du processus enfant avant la fin du processus principal