Compréhension approfondie des processus et des threads de Python dans l'article précédent

La colonne

Tutoriel vidéo Python présente les processus et les threads.

Le processus et le thread sont des concepts de base dans le système d'exploitation. Il existe des avantages, des inconvénients et des différences entre eux. Alors, comment utiliser les processus en Python et le thread ?

CPU

Le cœur de l'ordinateur est le CPU, qui entreprend toutes les tâches informatiques de l'ordinateur. Le CPU est comme une usine, fonctionnant tout le temps, et le système d'exploitation gère l'ordinateur. et est responsable de la planification des tâches, de l'allocation et de la gestion des ressources.

Processus

Un processus fait référence à une unité de base qui peut fonctionner indépendamment dans le système et est utilisée comme unité de base pour l'allocation des ressources. Il est composé d'un ensemble d'instructions machine, de données et. piles, etc., et est un processus qui peut s'exécuter de manière indépendante.

Lorsque nous ouvrirons notre ordinateur, nous verrons les processus et les threads. Cliquez sur Poste de travail pour voir les opérations du processeur.

Comme le montre la figure, le processeur exécute un total de 190 processus et 2620 threads. Par exemple, lorsque nous cliquons à nouveau sur QQ et que nous nous connectons à un autre compte, un autre processus QQ sera ouvert.

Donc, si vous souhaitez vous connecter à plusieurs comptes WeChat sur votre ordinateur. Trouvez simplement votre raccourci WeChat, faites un clic droit pour afficher les propriétés et copiez le lien dans la cible ; créez un nouveau bloc-notes, donnez-lui un nom, double-cliquez pour l'ouvrir et entrez start "" dedans (notez que la citation les marques sont en anglais, et les guillemets avant et après Il y a des espaces), collez le lien que vous venez de copier (c'est-à-dire le chemin d'accès à l'installation de WeChat puis copiez la ligne entière et collez quelques lignes si vous souhaitez l'ouvrir) ; autant de comptes WeChat que possible ; enregistrez le fichier et remplacez le suffixe par bat. Double-cliquez simplement pour exécuter.

Thread

Thread (Thread) est également appelé processus léger. Il s'agit de la plus petite unité que le système d'exploitation peut effectuer. dans le processus, est l'unité opérationnelle réelle dans le processus.

Rappelez-vous le blog écrit par Ruan Yifeng : supposons que la puissance dans l'usine est limitée et ne peut être utilisée que par un atelier à la fois. En d’autres termes, lorsqu’un atelier commence à fonctionner, les autres ateliers doivent cesser de fonctionner. La signification derrière cela est qu’un seul processeur ne peut exécuter qu’une seule tâche à la fois.

Un processus est comme une usine, il représente une tâche unique que le processeur peut gérer. À tout moment, le processeur exécute toujours un processus et les autres processus sont dans un état non exécuté.

Les fils sont comme des ouvriers dans un atelier. Un processus peut inclure plusieurs threads qui travaillent ensemble pour accomplir une tâche.

Pour résumer : Un programme peut contenir plusieurs processus, et plusieurs processus s'exécutent simultanément et sont indépendants les uns des autres. Par conséquent, un processus est également l'unité de base d'allocation et de planification des ressources dans le système. Techniquement parlant : un processus est une instance d'un programme lorsqu'il est exécuté. Un thread est la plus petite unité d’exécution et un processus se compose d’au moins un thread. La façon dont les processus et les threads sont planifiés est entièrement déterminée par le système d'exploitation.

L'utilisation des threads et des processus en Python

Parlons maintenant de l'utilisation des threads et des processus en Python.

En Python, la prise en charge des threads est fournie via deux bibliothèques standards thread et Threading, et threading encapsule thread. Le module threading fournit Thread, Lock, RLOCK, Condition et d'autres composants

Thread

L'utilisation des threads et des processus en Python se fait via la classe Thread . Ce cours est dans nos modules _thread et threading. Nous importons généralement via threading.

Par défaut, tant qu'il n'y a pas d'erreur dans l'interpréteur, le fil de discussion est disponible.

>> from threading import Thread复制代码

Ce qui suit sont des descriptions de paramètres courants et des méthodes d'instance de la classe Thread.

Regardons un exemple multithread standard dans la documentation officielle.

import threading
import time
# 定义线程要运行的函数
def func(name):
    # 为了便于观察，睡眠2秒
    time.sleep(2)
    print("My name is %s\t" % name)

# 创建第一个线程的实例，args参数是一个元组，后面必须加逗号分隔
t1 = threading.Thread(target=func, args=("Runsen",))
# 创建第二个线程的实例
t2 = threading.Thread(target=func, args=("Maoli",))
t1.start()
t2.start()
# 先打印线程名 
print(t1.getName())
print(t2.getName())复制代码

Étant donné que les deux threads s'exécutent en même temps, print le résultat du processus d'impression ne s'enroule pas.

J'ai écrit le code suivant ci-dessous pour approfondir l'utilisation du module de threading.

# -*- coding：utf-8 -*-# time ：2019/4/9 21:52# author: Runsenimport threadingimport timedef fun1():
    print('hello')
    time.sleep(2)
    print('Bye')def fun2():
    print('hi')
    time.sleep(2)
    print('OUT')
t1 = threading.Thread(target=fun1)
t2 = threading.Thread(target=fun2)
t1.start()
t2.start()# t1.join()# t2.join()print('主线程完毕')复制代码

Ce qui suit est le résultat.

hello
hi
主线程完毕
Bye
OUT复制代码

我们先不加join()来阻塞，t1和t2两个线程同时执行，由于位置关系先打印hello，再打印hi，这个时候都sleep2秒钟，但是它sleep2秒钟，主程序还是在执行，所以下面打印print('主线程完毕')，最后才打印Bye和OUT。

线程间变量的共享

在多线程中，所有变量对于所有线程都是共享的，因此，线程之间共享数据的最大危险在于多个线程同时修改一个变量，那就乱套了，所以我们需要互斥锁，来锁住数据。

代码如上图所示，上面代码中打印的a是1还是2？

答案是：2。因为出现了global关键字，线程间变量的共享，在func函数中的a是全局变量。因此在函数中a的值发生了变化。

下面，我们提高一点点难度，代码如下图所示，还是猜一猜a是啥东西。注意:这里出现了join来阻塞，并且增加了加和减的操作。

相信很多人都认为是0，其实这个a的值是变化的，可能这次是0 ，下次是1，还有可能是1000000，比如，我可以

a就是在[-1000000，1000000]中的一个随机数。

为什么呢？这是因为虽然他们是同时运行的，但是同时在修改我们的a，那就乱了。a在for i in range(1000000)，就是遍历了1000000，incr和decr的方法都加上一起了，在这1000000次遍历中，不知道有多少加，多少减，比如，我1000000都是加，没有减，a就是1000000，但是这种情况的概率很低。

如果你就是想出现0，其实只需要加一个互斥锁就可以了。这样你加多少次，我就减多少次，加减的次数不会叠加。因此来了lock的用法，具体代码如下图所示。

这个a怎么运行都是 0。因为我们把这个a锁上了，这样就加1000000次，减1000000次，怎么出来都是我们的0。

相关免费学习推荐：python视频教程

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!