Was ist ein Prozess? Was ist ein Thread?

Grundlagen:

Was ist ein Prozess?

Der Speicher jedes Programms ist unabhängig, zum Beispiel: Die Welt kann nicht auf QQ zugreifen.

Prozess: QQ ist der gesamten Betriebssystemverwaltung ausgesetzt, einschließlich Aufrufen verschiedener Ressourcen (Speicherverwaltung, Netzwerkschnittstellenaufrufe usw.). Das Starten eines QQ bedeutet das Starten eines Prozesses.

Was ist ein Thread?

Ein Thread ist die kleinste Einheit, die das Betriebssystem zur Berechnungsplanung durchführen kann. Thread ist im Prozess enthalten und die eigentliche Bedieneinheit im Prozess.

Es muss mindestens einen Thread in einem Prozess geben.

Ein Thread bezieht sich auf einen einzelnen sequentiellen Kontrollfluss in einem Prozess.

Ein CAS-Prozess führt mehrere Threads gleichzeitig aus, jeder Thread führt parallel verschiedene Aufgaben aus und die Threads sind unabhängig voneinander.

Der Unterschied zwischen Threads und Prozessen:

Prozess: eine Sammlung verschiedener Ressourcenverwaltungsfunktionen

Thread: die kleinste Planungseinheit des Betriebssystems, bei der es sich um eine Sammlung von Anweisungen handelt

Beziehung:

Der erste Thread im Prozess ist der Hauptthread. Andere Threads können ebenfalls Threads erstellen 🎜 >Ein Prozess hat einen übergeordneten Prozess, einen untergeordneten Prozess, einen unabhängigen Speicherbereich, eine eindeutige Prozesskennung und eine PID.

Was ist Kontextwechsel?

Kontextwechsel, auch Prozesswechsel oder Aufgabenwechsel genannt, bezieht sich auf den Wechsel der CPU von einem Prozess oder Thread zu einem anderen. Zum Beispiel wie folgt:

a. Öffnen Sie QQ und WeChat, wechseln Sie dann zu WeChat, um zu chatten, und wechseln Sie dann zu QQ.

b. Die CPU-Konfiguration des Computers beträgt 4 Kerne. Beim Wechseln zwischen mehreren Anwendungen gibt es keine Verzögerungen, da die CPU-Aufgaben schnell ausgeführt werden . , daher gibt es keine Verzögerung beim Wechseln zwischen Anwendungen;

Einzelner Thread:

Ausführungsergebnis:

import timeimport requestsdef get_res():
    urls = ['','','','']
    start = time.time()for url in urls:print(url)
        resp = requests.get(url)print(resp)
    end = time.time()print('单线程运行时间:', end - start)

Erklärung:

http://www.baidu.com<Response [200]>https://www.taobao.com/
<Response [200]>https://www.jd.com/
<Response [200]>http://www.meilishuo.com/
<Response [200]>单线程运行时间: 1.0470597743988037

a. Die CPU wird nacheinander angefordert

b. Sofern die CPU keine Antwort von einer URL erhält, wird sie die nächste URL nicht anfordern

c. Netzwerkanfragen dauern lange, sodass die CPU im Leerlauf bleibt, während sie auf die Rückkehr von Netzwerkanfragen wartet

Multithreading:

Laufergebnisse:

import timeimport threadingdef run(count):#每次执行该方法，需要休息2stime.sleep(2)print(count)#开始创建多线程start = time.time()for i in range(5):#创建线程，指定运行哪个函数，也就是指定哪个函数运行需要创建多线程#target=要运行的函数名# args=函数运行传入的参数，run方法需要传入count，把创建th = threading.Thread(target=run, args=(i, ))#启动线程    th.start()#多线程创建完毕且运行结束end = time.time()print('运行时间：', end - start)

Erklärung:

运行时间： 0.0
104
2
3

a. Threads, da Sie vor der Ausführung 2 Sekunden warten müssen, sodass die Laufzeit von Multithreading mindestens 2 Sekunden beträgt. Was ist also das gedruckte Ergebnis?

Die gedruckte Laufzeit ist die Laufzeit des Hauptthreads, denn wenn eine Python-Datei ausgeführt wird und Multithreading nicht gestartet ist, läuft mindestens ein Thread

Threads sind zunächst unabhängig voneinander. Wenn Threading erreicht wird, wird ein Thread erstellt, der die Schleifenmethode ausführt und der Hauptthread führt andere Operationen aus >

　Der Hauptthread wartet nicht, bis andere Threads beendet sind, bevor er endet

b Die gedruckten Zähldaten sind ungeordnet, da es sich um mehrere Threads handelt run run Die Methode besteht nicht darin, die nächste Anfrage zu stellen, nachdem die erste Anfrage abgeschlossen ist, sondern darin, einen Thread zu erstellen und dann die run-Methode auszuführen und dann einen weiteren Thread zu erstellen. Nach der Ausführung des Threads wird das Ergebnis gedruckt c. Es wurden insgesamt 5 Threads erstellt

Wenn Sie die Gesamtausführungszeit von Multi-Threads zählen möchten, also die Zeit ab Beginn der Thread-Erstellung bis zum Ende des Threads (Sie müssen die Unterschiede zwischen den Threads nicht berücksichtigen) ausgeführt wird), lautet die Operation wie folgt:

join() wait (warten Sie, bis der Thread endet)

Ausführungsergebnis:

import timeimport threadingdef run(count):#每次执行该方法，需要休息2stime.sleep(2)print(count)#开始创建多线程start = time.time()#存放创建的所有线程threads_list = []for i in range(5):#创建线程，指定运行哪个函数，也就是指定哪个函数运行需要创建多线程#target=要运行的函数名# args=函数运行传入的参数，run方法需要传入count，把创建th = threading.Thread(target=run, args=(i, ))#启动线程    th.start()#把启动的每一个线程添加到线程组内    threads_list.append(th)for t in threads_list:#主线程循环等待每个子线程运行完毕， t代表每个子线程t.join()  #等待线程结束#多线程创建完毕且运行结束end = time.time()print('运行时间：', end - start)

Daemon-Thread

Daemon-Thread: Nachdem der Haupt-Thread beendet ist, wird er trotzdem beendet davon, ob die Ausführung des Dämonenfadens endet.

01
2
4
3运行时间： 2.0011146068573

Zum Beispiel hat der Kaiser viele Diener. Nach dem Tod mussten so viele Diener mit ihm begraben werden.

Solange der Nicht-Daemon-Thread endet, unabhängig davon, ob der Daemon-Thread endet oder nicht, endet das Programm

GIL 全局解释器锁

例如 4核机器上 
Python创建4线程，四个线程均匀分到多核上，但是同时只能一核在处理数据。 
python调用操作系统、C语音的原生接口，在出口做了设置。全局解释器锁，保证数据统一 
所以有人说python的线程是假线程。 
在修改数据的时候，为了防止数据改乱了，所以多线程就变成串行处理，但是以为是python在处理，实际上是调用了操作系统的C语音的线程接口，所以中间的过程，python控制不了了，只知道结果。在这种情况下，设置的方式是出口控制，虽然四个线程，但是同一时间只有一个线程在工作。 
　 
所以这算是python的一个缺陷，但是也不能说是python的缺陷，是Cpython的缺陷。因为Cpython是C语音写的，以后python的未来是PYPY。 

线程锁

线程锁，又叫互斥锁

线程之间沟通：保证同一时间只有一个线程修改数据

python2.x 中需要加锁，Python3.x中加不加锁都一样，因为解释器做了优化

import threadingfrom threading import Lock#创建lock对象num = 0
lock = Lock()   #申请一把锁,创建锁的对象def run2():global num
    lock.acquire()      #修改数据前 加锁num += 1lock.release()      #修改后释放解锁lis = []for i in range(5):#创建线程t = threading.Thread(target=run2)#启动线程    t.start()#将启动的线程添加到线程组内    lis.append(t)for t in lis:#等待线程运行结束    t.join()#num的值为5，执行多次后，会出现不一样的值print('over', num)

RLock 递归锁

大锁中还有小锁、递归锁，解锁时就混了，所以用递归锁，Rlock()

import threading,timedef run1():print("grab the first part data")
    lock.acquire()global num
    num +=1lock.release()return numdef run2():print("grab the second part data")
    lock.acquire()global  num2
    num2+=1lock.release()return num2def run3():
    lock.acquire()
    res = run1()print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()print(res,res2)if __name__ == '__main__':

    num,num2 = 0,0
    lock = threading.RLock()  # 声明递归锁# lock = threading.Lock() # 用互斥锁，会锁死了，弄混锁情况，可以试一下for i in range(10):
        t = threading.Thread(target=run3)
        t.start()while threading.active_count() != 1:print(threading.active_count())else:print('----all threads done---')print(num,num2)

 多线程的另一种写法：

import threadingimport timeclass MyThread(threading.Thread):def __init__(self, num):
        threading.Thread.__init__(self)
        self.num = numdef run(self):  # 定义每个线程要运行的函数print("running on number:%s" % self.num)
        time.sleep(3)if __name__ == '__main__':
    t1 = MyThread(1)
    t2 = MyThread(2)
    t1.start()
    t2.start()

多进程(了解即可)：

python里面的多线程，是不能利用多核cpu的，如果想利用多核cpu的话，就得使用多进程

多进程适用CPU密集型任务

多线程适用io密集型任务

from multiprocessing import Processdef f(name):
    time.sleep(2)print('hello', name)if __name__ == '__main__':for i in range(10):
        p = Process(target=f, args=('niu',))
        p.start()

Das obige ist der detaillierte Inhalt vonWas ist ein Prozess? Was ist ein Thread?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!