Ausführliches Verständnis der Prozesse und Threads von Python im vorherigen Artikel

In der Spalte „Python-Video-Tutorial“ werden Prozesse und Threads vorgestellt.

Prozesse und Threads sind grundlegende Konzepte im Betriebssystem. Es gibt einige Vorteile, Nachteile und Unterschiede zwischen ihnen. Wie werden Prozesse und Threads in Python verwendet?

CPU

Der Kern des Computers ist die CPU, die alle Rechenaufgaben des Computers übernimmt. Die CPU ist wie eine Fabrik, die ständig läuft, während das Betriebssystem den Computer verwaltet und für die Aufgabenplanung verantwortlich ist. Ressourcenzuweisung und -verwaltung.

Prozess

Ein Prozess bezieht sich auf eine Grundeinheit, die unabhängig im System ausgeführt werden kann und als Grundeinheit für die Ressourcenzuweisung verwendet wird. Er besteht aus einer Reihe von Maschinenanweisungen, Daten und Stapeln usw. und ist ein aktive Einheit, die unabhängig laufen kann.

Wenn wir unseren Computer öffnen, sehen wir Prozesse und Threads. Klicken Sie auf „Arbeitsplatz“, um die CPU-Vorgänge anzuzeigen.

Wie im Bild gezeigt, führt die CPU insgesamt 190 Prozesse und 2620 Threads aus. Wenn wir beispielsweise erneut auf QQ klicken und uns bei einem anderen Konto anmelden, wird ein weiterer QQ-Prozess geöffnet.

Wenn Sie sich also bei mehreren WeChat auf Ihrem Computer anmelden möchten. Suchen Sie einfach Ihre WeChat-Verknüpfung, klicken Sie mit der rechten Maustaste, um die Eigenschaften anzuzeigen, kopieren Sie den Link in das Ziel, erstellen Sie einen neuen Notizblock, geben Sie ihm einen zufälligen Namen, doppelklicken Sie, um ihn zu öffnen, und geben Sie start „“ ein. Code> (Hinweis: Die Anführungszeichen sind auf Englisch und es gibt Leerzeichen davor und danach), fügen Sie den Link ein, den Sie gerade kopiert haben (d. h. den Pfad, in dem WeChat installiert ist). Kopieren Sie dann die gesamte Zeile und fügen Sie ggf. einige Zeilen ein Sie möchten so viele WeChat-Konten wie möglich eröffnen. Speichern Sie die Datei und ändern Sie das Suffix in bat . Zum Ausführen einfach doppelklicken. <p></p> <img class="origin_image zh-lightbox-thumb lazyload lazy" src="/static/imghwm/default1.png" data-src="https://img.php.cn/upload/article/000/000/052/9926e686d617ff28a6bd7be1334599ef-1.jpg?x-oss-process=image/resize,p_40" style="max-width:90%" daten data- style="max-width:90%" alt="Ausführliches Verständnis der Prozesse und Threads von Python im vorherigen Artikel" ><p></p> <h1 id="Thread-code-start-code-注意引号为英文状态-且前后有空格-将刚刚复制的链接-也就是微信安装的路径-粘贴进去-然后复制整行-想开几个微信就粘贴几行-保存文件-更改后缀名为-bat-双击运行即可">Thread<code>start ""（注意引号为英文状态，且前后有空格），将刚刚复制的链接(也就是微信安装的路径）粘贴进去；然后复制整行，想开几个微信就粘贴几行；保存文件，更改后缀名为 bat。双击运行即可。

线程

线程（Thread）也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。

记得阮一峰写过的博客：假定工厂的电力有限，一次只能供给一个车间使用。也就是说，一个车间开工的时候，其他车间都必须停工。背后的含义就是，单个CPU一次只能运行一个任务。

进程就好比工厂的车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其他进程处于非运行状态。

线程就好比车间里的工人。一个进程可以包括多个线程，协同完成一个任务。

总结来说：程序可以包含多个进程，多个进程并发执行，相互独立，因此，进程也是系统进行资源分配和调度基本单位。专业化来说：进程是指程序执行时的一个实例。线程是最小的执行单元，而进程由至少一个线程组成。如何调度进程和线程，完全由操作系统决定。

在Python中线程和进程的使用

现在讲下在Python线程和进程的使用。

在Python中，通过两个标准库 thread和 Threading提供对线程的支持,threading对 thread进行了封装。threading模块中提供了 Thread,Lock, RLOCK, Condition等组件

Thread

在Python中线程和进程的使用就是通过Thread这个类。这个类在我们的_thread和threading模块中。我们一般通过threading导入。

默认情况下，只要在解释器中，如果没有报错，则说明线程可用。

>> from threading import Thread复制代码

下面是Thread类的常用参数说明和实例方法。

我们看一个官方文档中标准的多线程的例子。

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())复制代码

由于两个线程是同时运行的，所以print

Thread (Thread) wird auch als leichter Prozess bezeichnet, mit dem das Betriebssystem die Berechnungsplanung durchführen kann Die kleinste Einheit, die in den Prozess einbezogen wird, ist die eigentliche Betriebseinheit im Prozess.

Ich erinnere mich an den Blog von Ruan Yifeng: Gehen Sie davon aus, dass der Strom in der Fabrik begrenzt ist und jeweils nur an eine Werkstatt geliefert werden kann. Mit anderen Worten: Wenn eine Werkstatt ihre Arbeit aufnimmt, müssen andere Werkstätten ihre Arbeit einstellen. Der Sinn dahinter ist, dass eine einzelne CPU jeweils nur eine Aufgabe ausführen kann.

Ein Prozess ist wie eine Fabrikhalle, er stellt eine einzelne Aufgabe dar, die die CPU bewältigen kann. Zu jedem Zeitpunkt führt die CPU immer einen Prozess aus, und andere Prozesse befinden sich in einem nicht ausgeführten Zustand.

🎜Fäden sind wie Arbeiter in einer Werkstatt. Ein Prozess kann mehrere Threads umfassen, die zusammenarbeiten, um eine Aufgabe abzuschließen. 🎜🎜Zusammenfassend:Ein Programm kann mehrere Prozesse enthalten, und mehrere Prozesse werden gleichzeitig ausgeführt und sind unabhängig voneinander. Daher ist ein Prozess auch die Grundeinheit der Ressourcenzuweisung und -planung im System. Technisch gesehen ist ein Prozess eine Instanz eines Programms, wenn es ausgeführt wird. Ein Thread ist die kleinste Ausführungseinheit und ein Prozess besteht aus mindestens einem Thread. Wie Prozesse und Threads geplant werden, wird vollständig vom Betriebssystem bestimmt. 🎜

Die Verwendung von Threads und Prozessen in Python🎜🎜Lassen Sie uns nun über die Verwendung von Threads und Prozessen in Python sprechen. 🎜🎜In Python wird Unterstützung für Threads durch zwei Standardbibliotheken thread und Threading bereitgestellt, threading versus thread > Gekapselt. Das Modul threading stellt Komponenten wie Thread, Lock, RLOCK, Condition🎜 bereit

Thread🎜🎜Die Verwendung von Threads und Prozessen in Python erfolgt über die Thread-Klasse. Diese Klasse ist in unseren Modulen _thread und threading enthalten. Normalerweise importieren wir über Threading. 🎜🎜Solange im Interpreter kein Fehler vorliegt, bedeutet dies standardmäßig, dass der Thread verfügbar ist. 🎜

# -*- 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('主线程完毕')复制代码

🎜Im Folgenden finden Sie allgemeine Parameterbeschreibungen und Instanzmethoden der Thread-Klasse. 🎜🎜🎜🎜🎜🎜Schauen wir uns ein Standard-Multithreading-Beispiel in der offiziellen Dokumentation an. 🎜

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

🎜Da die beiden Threads gleichzeitig ausgeführt werden, enthält das Ergebnis der Druckverarbeitung print keine neue Zeile. 🎜🎜🎜🎜🎜 Unten habe ich den folgenden Code geschrieben, um die Verwendung des Threading-Moduls zu vertiefen. 🎜rrreee🎜Das Folgende ist die Ausgabe. 🎜

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视频教程

Das obige ist der detaillierte Inhalt vonAusführliches Verständnis der Prozesse und Threads von Python im vorherigen Artikel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!