1. 多任務 - 線程

參考
首先考慮一個沒有多任務的程序:

import time

def sing():
    # 唱歌 5 秒鐘
    for i in range(5):
        print("-----菊花臺ing....-----")
        time.sleep(1)


def dance():
    # 跳舞 5秒鐘
    for i in range(5):
        print("-----跳舞.....-----")
        time.sleep(5)


def main():
    sing()
    dance()

if __name__ == "__main__":
    main()

此時,你想同時執行唱歌、跳舞是無法做到的。如果想要同時執行,可以使用python提供的Thread來完成.

import time
from threading import Thread


def sing():
    # 唱歌 5 秒鐘
    for i in range(5):
        print("-----菊花臺ing....-----")
        time.sleep(1)


def dance():
    # 跳舞 5秒鐘
    for i in range(5):
        print("-----跳舞.....-----")
        time.sleep(1)


def main():
    t1 = Thread(target=sing)
    t2 = Thread(target=dance)
    t1.start()
    t2.start()


if __name__ == "__main__":
    main()

關鍵點:

from threading import Thread: 從threading包鍾導入Thread
t1 = Thread(target=sing): 使用這個將函數變爲線程執行的函數~

1.1 多任務的概念

上面體驗瞭如何同時執行2個異步函數~下面補充一下多任務的概念.

簡單地說,就是操作系統可以同時運行多個任務.例如: 一邊逛瀏覽器,一遍聽音樂

單核CPU執行多任務: 單核CPU執行多任務的關鍵在於,將cpu的時間切片. 任務1執行0.01秒,然後任務2執行0.01秒,在切到任務1執行0.01秒。由於CPU的運算速度很快,因此,我們感覺就行所有任務都在同時執行一樣

多核CPU執行多任務: 真的並行執行多任務只能在多核CPU上實現. 但是,在平常的代碼中,任務數量會遠遠的大於CPU的核心數,因此操作系統會將任務輪流調度到各個核心上執行~

並行: 同一時刻真正運行在不同的CPU上的任務

併發: 在一個很短的時間內,利用CPU的告訴運轉.執行多個任務

1.2 查看當前線程數量

在某些情況下,需要查看當前程序中的線程數量,可以使用threading.enumerate()進行嘗試

import threading
from time import sleep, ctime

def sing():
    for i in range(3):
        print("正在唱第%d首哥" % i)
        sleep(2)
        
def dance():
    for i in range(3):
        print("正在跳第%d支舞" %i)
        sleep(2)
 
if __name__ == "__main__":
    print("開始時間: %s" % ctime())
    
    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)
    
    t1.start()
    t2.start()
    
    while True:
        length = threading.enumerate()
        print("當前的總線程數爲: %d" % length)
        if length <= 1:
            break
        sleep(1)
        
    print("結束時間: %s" % ctime())

注意:

當調用Thread的時候,不會創建線程
當調用Thread創建出來的實例對象的 start方法時,纔會創建線程以及讓這個線程開始運行

1.3 創建線程的第二種方法

第一種方法是通過: t = Thread(target = 函數名)來準備, t.start()來啓動

第二種方法是通過類繼承threading.Thread來實現,代碼如下:

import threading
import time

class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "I`m " + self.name + " @" + str(i)
            print(msg)
        
if __name__ == "__main__":
    t = MyThread()
    t.start()

說明:

類的繼承: class MyThread(threading.Thread)
通過類的方式創建的線程,必須在該類中定義run函數. 這樣當調用t.start()時候,新創建的線程會去類中尋找run函數並執行
一個t=MyThread()只會準備一個線程,當t.start()時,會創建線程~

1.4 線程共享全局變量

有些時候,多個不同的線程可能需要用到同一個變量,下面演示全局變量在多線程中的使用

from threading import Thread
import time


def work1():
    global g_num
    for i in range(3):
        g_num += 1

    print("---- in work1, g_num is %d ---" % g_num)


def work2():
    global g_num
    print("---- in work2, g_num is %d ---" % g_num)


def main():
    g_num = 100
    print("---- 線程創建執行之前 g_num is %d ---" % g_num)

    t1 = Thread(target=work1)
    t1.start()

    # 讓 t1線程先執行
    time.sleep(1)

    t2 = Thread(target=work2)
    t2.start()


if __name__ == "__main__":
    main()

注意:

在一個函數中對全局變量進行修改的時候需要看是否對全局變量的指向進行了修改
- 如果修改了指向,那麼必須使用global
- 如果僅修改了指向中的數據,則可以省略global

1.5 帶參數的線程調用

在調用的時候,可能需要傳遞參數進去.這就需要在線程準備的時候,使用args傳遞參數

from threading import Thread
from time import sleep

def test1(tmp):
    tmp.append(33)

def test2(tmp):
    tmp.append(66)

def main():
    num_arr = [11, 22]
    print(str(num_arr))
    t1 = Thread(target=test1, args=(num_arr,))
    t2 = Thread(target=test2, args=(num_arr,))
    t1.start()
    sleep(1)
    print(str(num_arr))
    t2.start()
    print(str(num_arr))

if __name__ == "__main__":
    main()

注意:

多任務共享數據的原因: 多個任務合作同時完成一個大任務~
- 一個任務獲取數據
- 一個任務處理數據
- 一個任務發送數據

1.6 資源競爭

共享變量會產生一個資源競爭的問題: 多個線程同時對一個全局變量進行修改~下面復現問題

import threading
import time

g_num = 0

def test1(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("test1: g_num: %d" % g_num)

def test2(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("test2: g_num: %d" % g_num)

def main():
    t1 = threading.Thread(target=test1, args=(1000000,))
    t2 = threading.Thread(target=test2, args=(1000000,))
    t1.start()
    t2.start()
    time.sleep(5)
    print("main: g_num: %d" % g_num)

if __name__ == "__main__":
    main()

test2: g_num: 1042014
test1: g_num: 1080242
main: g_num: 1080242

以上的原因如下:

假設:
- t1代表線程1,t2代表線程2
- g_num +=1 可分解成下面3個步驟:
  - 獲取 g_num的值, 記爲t1.1(t2.1)
  - 將g_num的值加1, 記爲t1.2(t2.2)
  - 將加1後的值存入g_num, 記爲t1.3(t2.3)
下面模擬執行步驟:(根據CPU的特性,分時執行)
- 假設先執行t1.1
- 再執行t1.2
- 然後執行t2.1, 此時重新獲取g_num的值
- 然後執行t1.3, 此時g_num的值並未改變

1.7 同步

以上問題可以通過線程同步來解決,在此之前,需要先了解互斥鎖:

當多個線程幾乎同時修改某一個共享數據的時候,需要進行同步控制
互斥鎖未資源引入了一個狀態: 鎖定/非鎖定
某個線程要更改共享數據的時候,先將其鎖定,此時資源的狀態爲"鎖定",其他線程不能更改;知道該線程釋放資源,將資源的狀態變爲"非鎖定",其他的線程才能再次鎖定該資源。互斥鎖保證了每次只有一個線程進行寫入操作,從而保證了多線程情況下數據的正確性

下面是互斥鎖的基本使用:

# 創建鎖
mutex = threading.Lock()

# 鎖定
mutex.acquire()

# 釋放
mutex.release()

注意:

如果這個鎖之前是沒有上鎖得,那麼acquire不會堵塞
如果在調用acquire之前已經被上鎖了,那麼acquire將會被阻塞直至release釋放

具體做法如下:

import threading
import time

def test1(num, ):
    global g_num, metex
    for i in range(num):
        metex.acquire()
        g_num += 1
        metex.release()
    print("test1: g_num: %d" % g_num)

def test2(num, ):
    global g_num, metex
    for i in range(num):
        metex.acquire()
        g_num += 1
        metex.release()
    print("test2: g_num: %d" % g_num)

g_num = 0
metex = threading.Lock()
def main():
    # 創建互斥鎖
    t1 = threading.Thread(target=test1, args=(1000000,))
    t2 = threading.Thread(target=test2, args=(1000000,))

    t1.start()
    t2.start()

    time.sleep(5)
    print("main: g_num: %d" % g_num)


if __name__ == "__main__":
    main()

說明:

全局變量中創建一個互斥鎖: metex = threading.Lock()
在原子代碼前面添上: metex.acquire()
- 原子代碼: 即要麼一次性全部執行,要麼不執行的不可分割的代碼
在原子代碼後面添上: metex.release()

1.8 死鎖

如果兩個線程分別佔用一部分資源,並且同時等待對方的資源,就會造成死鎖的現象。下面使用python實現一個簡單的死鎖程序:

import threading
import time

class MyThread1(threading.Thread):
    def run(self):
        # 線程1 假設下面都是原子代碼
        mutexA.acquire()
        print(self.name + "do1 up")
        time.sleep(1)
        mutexB.acquire()
        print(self.name + "do1 down")
        mutexB.release()
        mutexA.release()

class MyThread2(threading.Thread):
    def run(self):
        mutexB.acquire()
        print(self.name + "do2 up")
        time.sleep(1)
        mutexA.acquire()
        print(self.name + "do2 down")
        mutexA.release()
        mutexB.release()


mutexA = threading.Lock()
mutexB = threading.Lock()

def main():
    t1 = MyThread1()
    t2 = MyThread2()
    t1.start()
    t2.start()


if __name__ == "__main__":
    main()

說明:

進入線程1,將mutexA鎖定,然後休眠1秒
進入線程2,將mutexB鎖定,然後休眠1秒
之後同時在線程1和2中各自獲取mutexB,mutexA而進入相互等待階段,即死鎖。

python --- > 線程

1. 多任務 - 線程

1.1 多任務的概念

1.2 查看當前線程數量

1.3 創建線程的第二種方法

1.4 線程共享全局變量

1.5 帶參數的線程調用

1.6 資源競爭

1.7 同步

1.8 死鎖

EXCEL中下拉菜單中添加新選項或者刪除選項

號稱能打敗MLP的KAN到底行不行？數學核心原理全面解析

同事使用 insert into select 遷移數據，開開心心上線，上線後被公司開除！

Git使用經驗總結5-修改提交信息

Python 爬蟲：Spring Boot 反爬蟲的成功案例

京東科技數字化營銷能力的演進與最佳實踐| 京東雲技術團隊

Git使用經驗總結4-撤回上一次本地提交

Java中止線程的方式

壓榨數據庫的真實處理速度

[轉帖]Oracle Exadata 學習筆記之核心特性Part1

[pytorch、學習] - 3.9 多重感知機的從零開始實現

[pytorch、學習] - 3.7 softmax迴歸的簡潔實現

[pytorch、學習] - 3.5 圖像分類數據集

[pytorch、學習] - 3.6 softmax迴歸的從零開始實現

[mmdetection] - win10配置mmdetection(1.1和2.0) + 訓練網絡(faster-rcnn、mask-rcnn)

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結