Python中線程與互斥鎖

了解之前我們先了解一下什么是多任務?

概念: 幾個不同的事件在同時運行就是多任務, 這樣的話, 我們有牽扯到了真的多任務, 假的多任務;

並行: 真的多任務, 通過電腦的核數來確定

並發: 假的多任務, 即cpu的快速切換

線程

1.線程之間共享全局變量;

2.主線程等待子線程結束后才結束;

3.線程之間執行順序是無序的;

4.互斥鎖以及死鎖的問題.

 

demo 如何創建線程:

import threading
from time import sleep,ctime

def sing():
    for i in range(3):
        print("正在唱歌...%d"%i)
        sleep(1)

def dance():
    for i in range(3):
        print("正在跳舞...%d"%i)
        sleep(1)

if __name__ == '__main__':
    print('---開始---:%s'%ctime())

    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)

    t1.start()  // 注意當調用start時才真正的開始執行程序
    t2.start()

    #sleep(5) # 屏蔽此行代碼，試試看，程序是否會立馬結束？
    print('---結束---:%s'%ctime())

多線程之間共享全局變量

demo:

from threading import Thread
import time

def work1(nums):
    nums.append(44)
    print("----in work1---",nums)


def work2(nums):
    #延時一會，保證t1線程中的事情做完
    time.sleep(1)
    print("----in work2---",nums)

g_nums = [11,22,33]

t1 = Thread(target=work1, args=(g_nums,))
t1.start()

t2 = Thread(target=work2, args=(g_nums,))
t2.start()

運行結果是:

----in work1--- [11, 22, 33, 44]

----in work2--- [11, 22, 33, 44]

互斥鎖以及死鎖的問題:
思考: 為什么要使用互斥鎖?
線程之間共享資源, 這就導致了多個線程之間資源競爭, 導致了程序的運行.
思考: 鎖的好處以及壞處?
好處: 保證了同一時間內允許一個線程的完整執行
壞處: 降低了效率, 可能會造成死鎖問題

demo:

import threading
import time

# 定義一個全局變量
g_num = 0
def test1(num):
    global g_num

    for i in range(num):

        mutex.acquire()  # 上鎖 注意了此時鎖的代碼越少越好
        g_num += 1
        mutex.release()  # 解鎖
        
    print("-----in test1 g_num=%d----" % g_num)


def test2(num):
    global g_num
    for i in range(num):
        mutex.acquire()  # 上鎖
        g_num += 1
        mutex.release()  # 解鎖
    print("-----in test2 g_num=%d=----" % g_num)


# 創建一個互斥鎖，默認是沒有上鎖的
mutex = threading.Lock()


def main():
    t1 = threading.Thread(target=test1, args=(1000000,))
    t2 = threading.Thread(target=test2, args=(1000000,))

    t1.start()
    t2.start()

    # 等待上面的2個線程執行完畢....
    time.sleep(2)

    print("-----in main Thread g_num = %d---" % g_num)

if __name__ == "__main__":
    main()

死鎖: 在線程間共享多個資源的時候，如果兩個線程分別占有一部分資源並且同時等待對方的資源，就會造成死鎖

demo:

import threading
import time


def test1(num):
    print("---test1---")
    mutex1.acquire()
    print("test1 請求 mutex1")
    time.sleep(1)
    print("test1 獲得 mutex1")
    print("test1 請求 mutex2")
    mutex2.acquire()


def test2(num):
    print("---test2---")
    print("test2 請求 mutex2")
    mutex2.acquire()
    print("test2 獲得 mutex2")
    time.sleep(1)
    print("test2 請求 mutex1")
    mutex1.acquire()
   
mutex1 = threading.Lock()
mutex2 = threading.Lock()

def main():
    t1 = threading.Thread(target=test1, args=(1000000,))
    t2 = threading.Thread(target=test2, args=(1000000,))

    t1.start()
    t2.start()

if __name__ == "__main__":
    main()

思考: 死鎖如何避免?

1. 我們可以使用time.time()來進行一個超時等待;

2.銀行家算法

 有需要的話可以關注我的微信公眾號，會第一時間接收最新的知識。