關于Python中線程、進程、協程的簡介

這篇文章主要介紹關于Python中線程、進程、協程的簡介，文中介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們一定要看完！

一、線程（Thread）

　　1、定義：線程是操作系統能進行運算調度的最小單位，它包含在進程中，是進程的實際運作單位，一條線程是進程中一個單一順序的控制流，一個進程中可以并發多個線程，每條線程并行執行不同的任務。簡單理解：線程是一系列指令的集合，操作系統通過這些指令調用硬件。

　　2、同一個線程中的所有線程共享同一個內存空間資源，

二、進程（Progress）

　　1、定義：一個程序對各資源管理和調用的集合就是進程，比如QQ對網卡、內存、硬盤的調度和管理。對于操作系統來說，某一個進程是統一的整體。進程操作CPU就要先創建一個線程。進程本身是一個資源集合，執行需要靠線程。

三、線程和進程的區別

　　1、同個進程的線程之間共享內存空間，包括數據交換和通信，但不同進程之間的內存是獨立的

　　2、子進程是克隆了一份父進程的數據，子進程之間是互相獨立的，不能互相訪問，數據也不能共享。

　　3、兩個進程要通信，必須通過一個中間進程代理來實現。

　　4、一個線程可以操作同一個進程中的其他線程，但是進程只能操作子進程

　　5、對主線程的修改，可能會影響到其他的子線程，因為他們共享內存數據，但對主進程的修改，不會影響其他子進程。

四、多線程的代碼：

import threading
import time


class MyThread(threading.Thread):
    """
    # 用自定義一個子類的方式來啟動線程
    """

    def __init__(self, n):
        super(MyThread, self).__init__()
        self.n = n

    def run(self):
        print("你好，%s" % self.n)
        time.sleep(2)


start_time = time.time()
thread_list = []

# 啟動50個線程
for i in range(50):
    t1 = MyThread("t%s" % i)
    t1.start()
    thread_list.append(t1)
# 等待所有線程執行完畢后主線程再繼續執行
for i in thread_list:
    i.join()

print("總共執行時間：%s" % float(time.time() - start_time))

五、全局解釋器鎖（GIL）

　　1、定義：GIL 是最流行的 CPython 解釋器（平常稱為 Python）中的一個技術術語，中文譯為全局解釋器鎖，其本質上類似操作系統的 Mutex（即互斥鎖，意思是我修改的時候你不能修改，也就是鎖的意思）

　　2、功能：在 CPython 解釋器中執行的每一個 Python 線程，都會先鎖住自己，以阻止別的線程執行，這樣在同個時間一個CPU只執行一個線程。當然，CPython 不可能容忍一個線程一直獨占解釋器，check interval 機制會在一個時間段后釋放前面一個線程的全局鎖執行下一個線程，以達到輪流執行線程的目的。這樣一來，用戶看到的就是“偽”并行，即 Python 線程在交替執行，來模擬真正并行的線程。

　　3、CPython 引進 GIL，可以最大程度上規避類似內存管理這樣復雜的競爭風險問題，有了 GIL，并不意味著無需去考慮線程安全，因為即便 GIL 僅允許一個 Python 線程執行，但別忘了 Python 還有 check interval 這樣的搶占機制。所以就要引入線程鎖的機制，保證同個時間只有一個線程修改數據。

　　4、線程鎖的代碼如下

import threading
import time

num = 0

lock_obj = threading.Lock()


def run():
    # 申請鎖，使別的線程進不來
    lock_obj.acquire()
    global num
    time.sleep(1.1)
    num = num + 1
    # 解鎖，解鎖后別的線程可以進來
    lock_obj.release()


t_list = []
start_time = time.time()
# 啟動1000個線程
for i in range(100):
    t1 = threading.Thread(target=run)
    t1.start()
    t_list.append(t1)

for i in t_list:
    i.join()

time.sleep(3)
print("num:%d" % num)
print("time:%f" % float(time.time() - start_time))

六、遞歸鎖：

　　1、定義：一個鎖套另外一個鎖，形成鎖止循環，這種情況就要用到遞歸鎖RLOCK

import threading, time
def run1():
    print("grab the first part data")
    lock.acquire()
    global num
    num += 1
    lock.release()
    return num
def run2():
    print("grab the second part data")
    lock.acquire()
    global num2
    num2 += 1
    lock.release()
    return num2
def run3():
    lock.acquire()
    res = run1()
    print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()
    print(res, res2)
num, num2 = 0, 0
# 這里如果用Lock()就會無限循環，找不到具體用哪個鑰匙打開鎖，如果用RLock就不會，如果又多重鎖嵌套的情況一定要用遞歸鎖
lock = threading.Lock()
for i in range(1):
    t = threading.Thread(target=run3)
    t.start()
while threading.active_count() != 1:
    print("當前活躍的線程數：",threading.active_count())
else:
    print('----all threads done---')
    print("打印num和num2：",num, num2)

七、信號量（Semaphore）　　

　　1、允許同時間最多幾個線程進入執行，每出來一個進去一個，同時保持預先設置的線程最大允許數量。

import threading, time


def run(n):
    semaphore.acquire()
    time.sleep(1)
    print("run the thread: %s\n" % n)
    semaphore.release()

if __name__ == '__main__':
    semaphore = threading.BoundedSemaphore(5)  # 最多允許5個線程同時運行
    for i in range(22):
        t = threading.Thread(target=run, args=(i,))
        t.start()
while threading.active_count() != 1:
    pass  # print threading.active_count()
else:
    print('----all threads done---')
    #print(num)

八、事件（Event）：

　　1、定義：通過標識位和狀態，來實現線程之間的交互。簡單說，就是一個標志位，只有兩種狀態，一種是設置(Event.set())，一直是沒有設置(Event.clear())。

　　2、以下代碼實現一個簡單事件，一個線程控制紅綠燈，另外一個線程控制車子，當紅綠燈是紅色的時候，車子停止，綠的時候，車子行駛的效果

import time
import threading


event = threading.Event()

def lighter():
    count = 0
    event.set()  # 剛開始的標識位先設置綠燈
    while True:
        if 5 < count < 10:  # 改成紅燈
            event.clear()  # 把標志位清了
            print("\033[41;1mred light is on....\033[0m")
        elif count > 10:
            event.set()  # 變綠燈
            count = 0
        else:
            print("\033[42;1mgreen light is on....\033[0m")
        time.sleep(1)
        count += 1


def car(name):
    while True:
        if event.is_set():  # 代表綠燈
            print("[%s] running..." % name)
            time.sleep(1)
        else:
            print("[%s] sees red light , waiting...." % name)
            event.wait()
            print("\033[34;1m[%s] green light is on, start going...\033[0m" % name)


light = threading.Thread(target=lighter, )
light.start()

car1 = threading.Thread(target=car, args=("Tesla",))
car1.start()

　3、Event類還有兩個方法，wait()等待被設定，isset()判斷是否被設定

以上是關于Python中線程、進程、協程的簡介的所有內容，感謝各位的閱讀！希望分享的內容對大家有幫助，更多相關知識，歡迎關注億速云行業資訊頻道！