溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
小編這次要給大家分享的是解決python多線程和多線程變量共享問題，文章內容豐富，感興趣的小伙伴可以來了解一下，希望大家閱讀完這篇文章之后能夠有所收獲。
1、demo
第一個代碼是多線程的簡單使用，編寫了線程如何執行函數和類。
import threading
import time
class ClassName(threading.Thread):
"""創建類，通過多線程執行"""
def run(self):
for i in range(5):
print(i)
time.sleep(1)
def sing():
for i in range(1,11):
print("唱歌第 %d 遍" % i)
time.sleep(1)
def dance():
for i in range(1,16):
print("跳舞第 %d 遍" % i)
time.sleep(1)
def main():
t1 = threading.Thread(target = sing)
t2 = threading.Thread(target = dance)
t = ClassName()
# 啟動線程
t1.start()
t2.start()
t.start()
while True:
length = len(threading.enumerate())
print("正在運行的線程有 %s" %threading.enumerate())
if length <= 1:
break
time.sleep(1)
if __name__ == '__main__':
main()執行結果可以看到函數 sing、dance和類在同時執行，執行效果太長就不方截圖了
2、多線程共享變量
通過定義全局變量，然后再test1函數類部進行更改全局變量，test2打印全局變量。
import threading
import time
#定義全局變量
g_num = 0
def test1():
"""函數test1對全局變量進行更改"""
global g_num
for i in range(1,10):
g_num += 1
print("--- test1 線程 g_num = %d--- " % g_num)
def test2():
"""函數test2 打印全局變量"""
print("--- test2 線程 g_num = %d--- " % g_num)
def main():
t1 = threading.Thread(target=test1)
t2 = threading.Thread(target=test2)
# 啟動線程
t1.start()
# 增加睡眠是為了保證優先執行函數test1
time.sleep(1)
t2.start()
print("--- 主線程 g_num = %d--- " % g_num)
if __name__ == '__main__':
main()執行結果可以看出,在主線程和創建的兩個線程中讀取的是一樣的值，既可以表明在多線程中變量共享
3、資源競爭
在多線程兩個函數中同時更改一個變量時，由于cpu的計算能力，當修改參數的代碼塊無法一次性執行完成時，就會產生資源競爭
import threading
import time
# 定義全局變量
g_num = 0
def test1(num):
"""函數test1對全局變量進行更改"""
global g_num
for i in range(num):
g_num += 1
print("test1 線程 g_num = %d---" % g_num)
def test2(num):
"""函數test2對全局變量進行更改"""
global g_num
for i in range(num):
g_num += 1
print("tes2 線程 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(1)
print("主線程 g_num = %d---" % g_num)
if __name__ == '__main__':
main()可以先試試傳遞參數為100時，可以看到g_num = 200 這是因為函數代碼可以一次性執行完成，當參數為1000000時代碼無法一次性執行完成，g_num！= 2000000
4、互斥鎖
互斥鎖可以解決資源競爭的問題，原理很簡單，通過對代碼塊上鎖，保證該代碼執行完成前，其它代碼無法進行修改。執行完成后解鎖，其它代碼就可以執行了。
import threading
import time
# 創建變量
g_num = 0
# 創建鎖默認為開鎖狀態
mutex = threading.Lock()
def test1(num):
global g_num
for i in range(num):
# 上鎖
mutex.acquire()
g_num += 1
# 解鎖
mutex.release()
print("--- 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("--- 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(1)
print("--- 主線程 g_num = %d---" % g_num)
if __name__ == '__main__':
main()可以看到加了鎖之后，代碼執行不會出現資源競爭，結果也是正常的。互斥鎖，上鎖的代碼越少越好。
5、死鎖
當出現多個鎖時，就可能會產生死鎖這個情況。當關閉一個鎖時，這個鎖已經為關閉狀態的話，程序就會阻塞。就如同下面這個代碼中。函數test1關閉mutexB鎖時，函數test2提前將其關閉了，未進行解鎖，程序就會一直阻塞。
import threading
import time
# 創建兩個鎖A, B
mutexA = threading.Lock()
mutexB = threading.Lock()
def test1():
# 對muctexA上鎖
mutexA.acquire()
# mutexA上鎖后，延時1秒，等待mutexB上鎖
print("test1 ---do1---up---")
time.sleep(1)
# 此時會堵塞，因為mutexB已經上鎖
mutexB.acquire()
print("test1 ---do1---down---")
mutexB.release()
# 對mutexA解鎖
mutexA.release()
def test2():
# 對muctexB上鎖
mutexB.acquire()
# mutexB上鎖后，延時1秒，等待mutexA上鎖
print("test2 ---do1---up---")
time.sleep(1)
# 此時會堵塞，因為mutexB已經上鎖
mutexA.acquire()
print("test2 ---do1---down---")
mutexA.release()
# 對mutexA解鎖
mutexB.release()
def main():
t1 = threading.Thread(target=test1)
t2 = threading.Thread(target=test2)
t1.start()
t2.start()
if __name__ == '__main__':
main()代碼執行效果可以看到程序會一直阻塞
解決方法
1、在程序編寫時，就需要注意避免死鎖
2、可以參考銀行家算法
看完這篇關于解決python多線程和多線程變量共享問題的文章，如果覺得文章內容寫得不錯的話，可以把它分享出去給更多人看到。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
