Python快速上手（二十三）

Python3 多線程

多線程類似于同時執行多個不同程序，多線程運行有如下優點：

• 使用線程可以把占據長時間的程序中的任務放到后臺去處理。
• 用戶界面可以更加吸引人，比如用戶點擊了一個按鈕去觸發某些事件的處理，可以彈出一個進度條來顯示處理的進度。
• 程序的運行速度可能加快。
• 在一些等待的任務實現上如用戶輸入、文件讀寫和網絡收發數據等，線程就比較有用了。在這種情況下我們可以釋放一些珍貴的資源如內存占用等等。
• 多線程是一種并發編程的技術，允許程序同時執行多個線程。在Python中，我們可以使用threading模塊來實現多線程編程。

Python3 線程中常用的兩個模塊為：

• _thread
• threading(推薦使用)
  thread 模塊已被廢棄。可以使用 threading 模塊代替。所以，在 Python3 中不能再使用"thread" 模塊。為了兼容性，Python3 將 thread 重命名為 “_thread”。在本文中，我們將詳細講解Python3中的多線程編程，包括線程的創建、同步、優先級隊列等內容。

1. 線程的創建

在Python中，可以通過創建Thread類的實例來創建線程。以下是一個簡單的示例代碼：

#!/usr/bin/python3import threading
import timeexitFlag = 0class myThread (threading.Thread):def __init__(self, threadID, name, delay):threading.Thread.__init__(self)self.threadID = threadIDself.name = nameself.delay = delaydef run(self):print ("開始線程：" + self.name)print_time(self.name, self.delay, 5)print ("退出線程：" + self.name)def print_time(threadName, delay, counter):while counter:if exitFlag:threadName.exit()time.sleep(delay)print ("%s: %s" % (threadName, time.ctime(time.time())))counter -= 1# 創建新線程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)# 開啟新線程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主線程")

以上程序執行結果如下；

開始線程：Thread-1
開始線程：Thread-2
Thread-1: Wed Jan  5 17:34:54 2022
Thread-2: Wed Jan  5 17:34:55 2022
Thread-1: Wed Jan  5 17:34:55 2022
Thread-1: Wed Jan  5 17:34:56 2022
Thread-2: Wed Jan  5 17:34:57 2022
Thread-1: Wed Jan  5 17:34:57 2022
Thread-1: Wed Jan  5 17:34:58 2022
退出線程：Thread-1
Thread-2: Wed Jan  5 17:34:59 2022
Thread-2: Wed Jan  5 17:35:01 2022
Thread-2: Wed Jan  5 17:35:03 2022
退出線程：Thread-2
退出主線程

2. 線程同步

在多線程編程中，線程同步是非常重要的，它用于確保多個線程之間的數據訪問和操作是安全的，避免出現競爭條件和數據不一致的情況。Python提供了多種線程同步機制，包括鎖、信號量、事件、條件等。

2.1 鎖（Lock）

鎖是最基本的線程同步機制，通過獲取鎖可以阻止其他線程訪問共享資源，從而確保數據的一致性。在Python中，可以使用threading.Lock類來創建鎖對象，并通過acquire()和release()方法來獲取和釋放鎖。

import threadinglock = threading.Lock()def increment_counter():global counterlock.acquire()counter += 1lock.release()

在上面的示例中，我們創建了一個鎖對象lock，然后在increment_counter函數中使用acquire()方法獲取鎖，對counter變量進行操作后再通過release()方法釋放鎖。

2.2 信號量（Semaphore）

信號量是一種更加通用的線程同步機制，它可以控制多個線程同時訪問共享資源的數量。在Python中，可以使用threading.Semaphore類來創建信號量對象，并通過acquire()和release()方法來控制資源的訪問。

import threadingsemaphore = threading.Semaphore(2) # 允許同時有2個線程訪問共享資源def use_resource():semaphore.acquire()# 訪問共享資源semaphore.release()

在上面的示例中，我們創建了一個信號量對象semaphore，并設置允許同時有2個線程訪問共享資源。線程在訪問資源前需要先通過acquire()方法獲取信號量，訪問完成后再通過release()方法釋放信號量。

2.3 事件（Event）

事件是一種線程同步機制，用于實現線程之間的通信和協調。在Python中，可以使用threading.Event類來創建事件對象，并通過set()和clear()方法來設置和清除事件。

import threadingevent = threading.Event()def wait_for_event():event.wait() # 等待事件被設置# 處理事件def set_event():event.set() # 設置事件

在上面的示例中，我們創建了一個事件對象event，線程可以通過wait()方法等待事件被設置，通過set()方法設置事件，從而喚醒等待事件的線程。

2.4 條件（Condition）

條件是一種復雜的線程同步機制，它可以讓線程在特定條件下等待或喚醒。在Python中，可以使用threading.Condition類來創建條件對象，并通過wait()、notify()和notify_all()方法來實現線程的等待和喚醒。

import threadingcondition = threading.Condition()def wait_for_condition():with condition:condition.wait() # 等待條件# 處理條件def set_condition():with condition:condition.notify() # 喚醒等待條件的線程

在上面的示例中，我們創建了一個條件對象condition，線程可以通過wait()方法等待條件，通過notify()方法喚醒等待條件的線程。

3. 線程優先級隊列（Queue）

在Python中，線程優先級隊列（Priority Queue）是一種特殊的隊列，它可以根據元素的優先級來確定元素的順序。在標準的隊列中，元素是按照先進先出（FIFO）的順序進行排列的，而在優先級隊列中，元素的順序是根據其優先級來確定的，優先級高的元素會被優先處理。Python中的線程優先級隊列通常使用queue.PriorityQueue類來實現，它是線程安全的隊列，可以在多線程環境中安全地進行操作。
Queue 模塊中的常用方法:

• Queue.qsize() 返回隊列的大小
• Queue.empty() 如果隊列為空，返回True,反之False
• Queue.full() 如果隊列滿了，返回True,反之False
• Queue.full 與 maxsize 大小對應
• Queue.get([block[, timeout]])獲取隊列，timeout等待時間
• Queue.get_nowait() 相當Queue.get(False)
• Queue.put(item) 寫入隊列，timeout等待時間
• Queue.put_nowait(item) 相當Queue.put(item, False)
• Queue.task_done() 在完成一項工作之后，Queue.task_done()函數向任務已經完成的隊列發送一個信號
• Queue.join() 實際上意味著等到隊列為空，再執行別的操作

import queue
import threading
import timedef process_task(priority_queue):while True:priority, data = priority_queue.get()print(f'Processing task: {data}, Priority: {priority}')priority_queue.task_done()priority_queue = queue.PriorityQueue()# 啟動處理任務的線程
thread = threading.Thread(target=process_task, args=(priority_queue,))
thread.start()# 插入任務到優先級隊列
priority_queue.put((2, 'Task 1'))
priority_queue.put((1, 'Task 2'))
priority_queue.put((3, 'Task 3'))# 等待所有任務處理完成
priority_queue.join()

在上面的示例中，我們創建了一個優先級隊列priority_queue，并啟動了一個線程來處理任務。然后向優先級隊列中插入了三個任務，并通過join()方法等待所有任務處理完成。

總結

本文詳細講解了Python3中的多線程編程，包括線程的創建、同步、優先級隊列等內容。通過合理地使用多線程技術，可以提高程序的執行效率，實現并發處理任務。