Python中的多線程怎么實現(xiàn)

本文小編為大家詳細介紹“Python中的多線程怎么實現(xiàn)”，內(nèi)容詳細，步驟清晰，細節(jié)處理妥當，希望這篇“Python中的多線程怎么實現(xiàn)”文章能幫助大家解決疑惑，下面跟著小編的思路慢慢深入，一起來學習新知識吧。

前言：

多線程簡單理解就是：一個CPU，也就是單核，將時間切成一片一片的，CPU輪轉(zhuǎn)著去處理一件一件的事情，到了規(guī)定的時間片就處理下一件事情。

1.python中顯示當前線程信息的屬性和方法

# coding:utf-8
# 導入threading包
import threading
if __name__ == "__main__":
    print("當前活躍線程的數(shù)量", threading.active_count())
    print("將當前所有線程的具體信息展示出來", threading.enumerate())
    print("當前的線程的信息展示", threading.current_thread())

效果圖：

2.添加一個線程

# coding:utf-8
import threading
import time
def job1():
    # 讓這個線程多執(zhí)行幾秒
    time.sleep(5)
    print("the number of T1 is %s" % threading.current_thread())
if __name__ == "__main__":
    # 創(chuàng)建一個新的線程
    new_thread = threading.Thread(target=job1, name="T1")
    # 啟動新線程
    new_thread.start()
    print("當前線程數(shù)量為", threading.active_count())
    print("所有線程的具體信息", threading.enumerate())
    print("當前線程具體信息", threading.current_thread())

效果圖：

3.線程中的join函數(shù)

（1）預想的是，執(zhí)行完線程1，然后輸出All done…“理想很豐滿，現(xiàn)實卻不是這樣的”

# coding:utf-8
import threading
import time
def job1():
    print("T1 start")
    for i in range(5):
        time.sleep(1)
        print(i)
    print("T1 finish")
def main():
    # 新創(chuàng)建一個線程
    new_thread = threading.Thread(target=job1, name="T1")
    # 啟動新線程
    new_thread.start()
    print("All done...")
if __name__ == "__main__":
    main()

效果圖：

（2）為了達到我們的預期，我們使用join函數(shù)，將T1線程進行阻塞。join函數(shù)進行阻塞是什么意思？就是哪個線程使用了join函數(shù)，當這個線程正在執(zhí)行時，在他之后的線程程序不能執(zhí)行，得等這個被阻塞的線程全部執(zhí)行完畢之后，方可執(zhí)行！

# coding:utf-8
import threading
import time
def job1():
    print("T1 start")
    for i in range(5):
        time.sleep(1)
        print(i)
    print("T1 finish")
def main():
    # 新創(chuàng)建一個線程
    new_thread = threading.Thread(target=job1, name="T1")
    # 啟動新線程
    new_thread.start()
    # 阻塞這個T1線程
    new_thread.join()
    print("All done...")
if __name__ == "__main__":
    main()

效果圖：

4.使用Queue存儲線程的結(jié)果

線程的執(zhí)行結(jié)果，無法通過return進行返回，使用Queue存儲。

# coding:utf-8
import threading
from queue import Queue
"""
    Queue的使用
"""
def job(l, q):
    for i in range(len(l)):
        l[i] = l[i] ** 2
    q.put(l)
def multithreading():
    # 創(chuàng)建隊列
    q = Queue()
    # 線程列表
    threads = []
    # 二維列表
    data = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [6, 6, 6]]
    for i in range(4):
        t = threading.Thread(target=job, args=(data[i], q))
        t.start()
        threads.append(t)

    # 對所有線程進行阻塞
    for thread in threads:
        thread.join()
    results = []
    # 將新隊列中的每個元素挨個放到結(jié)果列表中
    for _ in range(4):
        results.append(q.get())
    print(results)
if __name__ == "__main__":
    multithreading()

效果圖：

5.線程鎖lock

當同時啟動多個線程時，各個線程之間會互相搶占計算資源，會造成程序混亂。

舉個栗子：

當我們在選課系統(tǒng)選課時，當前籃球課還有2個名額，我們?nèi)齻€人去選課。

選課順序為stu1 stu2 stu3,應該依次打印他們?nèi)齻€的選課過程，但是現(xiàn)實情況卻是：

# coding:utf-8
import threading
import time

def stu1():
    print("stu1開始選課")
    global course
    if course > 0:
        course -= 1
        time.sleep(2)
        print("stu1選課成功,現(xiàn)在籃球課所剩名額為%d" % course)
    else:
        time.sleep(2)
        print("stu1選課失敗，籃球課名額為0，請選擇其他課程")
def stu2():
    print("stu2開始選課")
    global course
    if course > 0:
        course -= 1
        time.sleep(2)
        print("stu2選課成功,現(xiàn)在籃球課所剩名額為%d" % course)
    else:
        time.sleep(2)
        print("stu2選課失敗，籃球課名額為0，請選擇其他課程")

def stu3():
    print("stu3開始選課")
    global course
    if course > 0:
        course -= 1
        time.sleep(2)
        print("stu3選課成功")
        print("籃球課所剩名額為%d" %course)
    else:
        time.sleep(2)
        print("stu3選課失敗，籃球課名額為0，請選擇其他課程")
if __name__ == "__main__":
    # 籃球課名額
    course = 2
    T1 = threading.Thread(target=stu1, name="T1")
    T2 = threading.Thread(target=stu2, name="T2")
    T3 = threading.Thread(target=stu3, name="T3")
    T1.start()
    T2.start()
    T3.start()

效果圖：

為了解決這種情況，我們使用lock線程同步鎖，在線程并發(fā)執(zhí)行時，保證每個線程執(zhí)行的原子性。有效防止了共享統(tǒng)一數(shù)據(jù)時，線程并發(fā)執(zhí)行的混亂。

改進的代碼如下：

# coding:utf-8
import threading
import time
def stu1():
    global lock
    lock.acquire()
    print("stu1開始選課")
    global course
    if course > 0:
        course -= 1
        time.sleep(2)
        print("stu1選課成功,現(xiàn)在籃球課所剩名額為%d" % course)
    else:
        time.sleep(2)
        print("stu1選課失敗，籃球課名額為0，請選擇其他課程")
    lock.release()


def stu2():
    global lock
    lock.acquire()
    print("stu2開始選課")
    global course
    if course > 0:
        course -= 1
        print("stu2選課成功,現(xiàn)在籃球課所剩名額為%d" % course)
    else:
        time.sleep(1)
        print("stu2選課失敗，籃球課名額為0，請選擇其他課程")
    lock.release()

def stu3():
    global lock
    lock.acquire()
    print("stu3開始選課")
    global course
    if course > 0:
        course -= 1
        time.sleep(1)
        print("stu3選課成功,現(xiàn)在籃球課所剩名額為%d" % course)
    else:
        time.sleep(1)
        print("stu3選課失敗，籃球課名額為0，請選擇其他課程")
    lock.release()

if __name__ == "__main__":
    # 籃球課名額
    course = 2
    # 創(chuàng)建同步鎖
    lock = threading.Lock()
    T1 = threading.Thread(target=stu1, name="T1")
    T2 = threading.Thread(target=stu2, name="T2")
    T3 = threading.Thread(target=stu3, name="T3")
    T1.start()
    T2.start()
    T3.start()

效果圖：

讀到這里，這篇“Python中的多線程怎么實現(xiàn)”文章已經(jīng)介紹完畢，想要掌握這篇文章的知識點還需要大家自己動手實踐使用過才能領(lǐng)會，如果想了解更多相關(guān)內(nèi)容的文章，歡迎關(guān)注億速云行業(yè)資訊頻道。