`threading` --- 執行緒層級的平行處理¶

此模組在較低層的 _thread 模組之上，建構了較高層的執行緒（threading）介面。

此模組在 WebAssembly 平台上不起作用或無法使用。更多資訊請參閱 WebAssembly 平台。

介紹¶

模組 threading 提供了一種方式，能在單一進程（process）中同時執行多個執行緒（一個進程中的較小執行單元）。它允許創造與管理執行緒，使多個任務可以平行執行並共享同一個記憶體空間。當任務屬於 I/O 密集型（I/O bound）時，執行緒特別有用，例如檔案操作或網路請求，因為這類任務的大部分時間都花在等待外部資源。

模組 threading 的一個典型使用情境是管理一個工作執行緒（worker threads）池，讓多個任務能夠同時被處理。以下是一個使用 Thread: 來創造並啟動執行緒的基本範例：

import threading
import time

def crawl(link, delay=3):
    print(f"crawl started for {link}")
    time.sleep(delay)  # Blocking I/O (simulating a network request)
    print(f"crawl ended for {link}")

links = [
    "https://python.org",
    "https://docs.python.org",
    "https://peps.python.org",
]

# Start threads for each link
threads = []
for link in links:
    # Using `args` to pass positional arguments and `kwargs` for keyword arguments
    t = threading.Thread(target=crawl, args=(link,), kwargs={"delay": 2})
    threads.append(t)

# Start each thread
for t in threads:
    t.start()

# Wait for all threads to finish
for t in threads:
    t.join()

在 3.7 版的變更: This module used to be optional, it is now always available.

也參考

concurrent.futures.ThreadPoolExecutor offers a higher level interface to push tasks to a background thread without blocking execution of the calling thread, while still being able to retrieve their results when needed.

queue provides a thread-safe interface for exchanging data between running threads.

asyncio offers an alternative approach to achieving task level concurrency without requiring the use of multiple operating system threads.

備註

In the Python 2.x series, this module contained camelCase names for some methods and functions. These are deprecated as of Python 3.10, but they are still supported for compatibility with Python 2.5 and lower.

CPython 實作細節： In CPython, due to the Global Interpreter Lock, only one thread can execute Python code at once (even though certain performance-oriented libraries might overcome this limitation). If you want your application to make better use of the computational resources of multi-core machines, you are advised to use multiprocessing or concurrent.futures.ProcessPoolExecutor. However, threading is still an appropriate model if you want to run multiple I/O-bound tasks simultaneously.

GIL and performance considerations¶

Unlike the multiprocessing module, which uses separate processes to bypass the global interpreter lock (GIL), the threading module operates within a single process, meaning that all threads share the same memory space. However, the GIL limits the performance gains of threading when it comes to CPU-bound tasks, as only one thread can execute Python bytecode at a time. Despite this, threads remain a useful tool for achieving concurrency in many scenarios.

As of Python 3.13, free-threaded builds can disable the GIL, enabling true parallel execution of threads, but this feature is not available by default (see PEP 703).

Reference¶

此模組定義了以下函式：

threading.active_count()¶

Return the number of Thread objects currently alive. The returned count is equal to the length of the list returned by enumerate().

The function activeCount is a deprecated alias for this function.

threading --- 執行緒層級的平行處理¶

介紹¶

GIL and performance considerations¶

Reference¶

`threading` --- 執行緒層級的平行處理¶