Python 3 中的多线程

17 Mar 2025 | 6 分钟阅读

程序或进程的最小执行单元称为线程，它可以独立运行，也可以作为操作系统调度的一部分。操作系统通过将进程划分为线程来实现计算机系统的多任务处理。线程是一种轻量级的循环，保证在框架上独立执行交互。当多个处理器在 Python 3 中运行一个程序时，每个处理器同时运行以执行自己的任务。

Python 3 中的多线程

Python 多线程

多线程是 Python 编程中一种串行化过程，通过在中央处理器（称为设置交换）的帮助下快速在线程之间切换，从而同时运行多个线程。此外，它还可以与其进程的主线程共享数据空间，这比单个进程更容易共享信息和与其他线程通信。多线程的目标是同时完成多个任务，从而提高应用程序的渲染和性能。

注意：Python 全局解释器锁 (GIL) 允许一次只运行一个线程，即使机器有多个处理器。

使用 Python 进行多线程的优势

以下是使用 Python 进行多线程的优点：

它保证了对 PC 系统资源的强大利用。
具有多个线程的应用程序响应更快。
它更具成本效益，因为它与子线程（子线程）共享资源及其状态。
由于亲近性，它使多处理器工程更具可行性。
通过同时运行多个线程，它减少了时间。
系统不需要大量内存来存储多个线程。

何时在 Python 中使用多线程？

它是提高应用程序性能的极其有价值的策略。程序员可以通过使用多线程同时运行应用程序的多个子任务。它允许线程与同一个处理器通信并共享文件、数据和内存等资源。此外，即使程序的一部分被阻塞或运行时间过长，它也能使用户更容易继续运行程序。

如何在 Python 中实现多线程？

Python 中有两种主要的多线程模块用于处理线程：Python。

thread 模块
threading 模块

线程模块

它在 Python 3 中启动，被指定为已弃用，并且只能通过支持向后兼容性的 _thread 访问。

语法

要实现 Python 中的线程模块，我们需要导入一个 thread 模块，然后定义一个函数，通过将目标设置为变量来执行某些操作。

Thread.py

import thread # import the thread module
import time # import time module

def cal_sqre(num): # define the cal_sqre function
    print(" Calculate the square root of the given number")
    for n in num: 
        time.sleep(0.3) # at each iteration it waits for 0.3 time
        print(' Square is : ', n * n)

def cal_cube(num): # define the cal_cube() function
    print(" Calculate the cube of  the given number")
    for n in num: 
        time.sleep(0.3) # at each iteration it waits for 0.3 time
        print(" Cube is : ", n * n *n)

arr = [4, 5, 6, 7, 2] # given array

t1 = time.time() # get total time to execute the functions
cal_sqre(arr) # call cal_sqre() function
cal_cube(arr) # call cal_cube() function

print(" Total time taken by threads is :", time.time() - t1) # print the total time

输出

Calculate the square root of the given number
 Square is:  16
 Square is:  25
 Square is:  36
 Square is:  49
 Square is:  4
 Calculate the cube of the given number
 Cube is:  64
 Cube is:  125
 Cube is:  216
 Cube is:  343
 Cube is:  8
 Total time taken by threads is: 3.005793809890747

Threading 模块

threading 模块是多线程的高级实现，用于在 Python 中部署一个应用程序。要使用多线程，我们需要在Python 程序中导入 threading 模块。

Thread 类方法

方法	描述
start()	start() 方法用于启动线程的活动。它每个线程只调用一次，以便线程的执行可以开始。
run()	run() 方法用于定义线程的活动，并且可以被扩展线程类的类覆盖。
join()	join() 方法用于阻塞执行其他代码，直到线程终止。

按照以下步骤在 Python 多线程中实现 threading 模块：

1. 导入 threading 模块

通过导入 threading 模块创建新线程，如下所示。

语法

threading 模块由 Thread 类组成，该类被实例化以创建 Python 线程。

2. 声明线程参数：它包含 Thread() 类中的目标函数、参数和 kwargs 作为参数。

Target：它定义了线程执行的函数名。
Args：它定义了传递给目标函数名的参数。

例如

import threading
def print_hello(n):
print("Hello, how old are you ", n)
t1 = threading.Thread( target = print_hello, args =(18, ))

在上面的代码中，我们将 print_hello() 函数调用作为 target 参数。print_hello() 包含一个参数 n，该参数传递给 args 参数。

3. 启动新线程：要在 Python 多线程中启动线程，请调用线程类的对象。start() 方法每个线程对象只能调用一次；否则，它会引发异常错误。

语法

t1.start()
t2.start()

4. Join 方法：它是线程类中用于停止主线程执行并等待直到线程对象完全执行的 join() 方法。当线程对象完成时，它会在 Python 中启动主线程的执行。

Joinmethod.py

import threading
def print_hello(n):
	Print("Hello, how old are you? ", n)
T1 = threading.Thread( target = print_hello, args = (20, ))
T1.start()
T1.join()
Print("Thank you")

输出

Hello, how old are you? 20
Thank you

运行上述程序时，join() 方法会停止主线程的运行，并等待 t1 线程运行完毕。一旦 t1 成功完成，主线程将开始执行。

注意：如果我们不使用 join() 方法，解释器可以执行 Python 程序中的任何打印语句。通常，它会执行第一个打印语句，因为解释器从程序的开头执行代码行。

5. Python 中线程的同步

它是一种线程同步机制，可确保没有两个线程可以同时运行程序的同一部分来访问共享资源。关键部分可用于描述这种情况。为了避免关键部分条件（其中两个线程不能同时访问资源），我们采用了竞争条件。

让我们编写一个程序来使用 Python 多线程中的 threading 模块。

Threading.py

import time # import time module
import threading
from threading import *
def cal_sqre(num): # define a square calculating function
    print(" Calculate the square root of the given number")
    for n in num: # Use for loop 
        time.sleep(0.3) # at each iteration it waits for 0.3 time
        print(' Square is : ', n * n)

def cal_cube(num): # define a cube calculating function
    print(" Calculate the cube of  the given number")
    for n in num: # for loop
        time.sleep(0.3) # at each iteration it waits for 0.3 time
        print(" Cube is : ", n * n *n)

ar = [4, 5, 6, 7, 2] # given array

t = time.time() # get total time to execute the functions
#cal_cube(ar)
#cal_sqre(ar)
th1 = threading.Thread(target=cal_sqre, args=(ar, ))
th2 = threading.Thread(target=cal_cube, args=(ar, ))
th1.start()
th2.start()
th1.join()
th2.join()
print(" Total time taking by threads is :", time.time() - t) # print the total time
print(" Again executing the main thread")
print(" Thread 1 and Thread 2 have finished their execution.")

输出

Calculate the square root of the given number
 Calculate the cube of the given number
 Square is:  16
 Cube is:  64
 Square is:  25
 Cube is:  125
 Square is:  36
 Cube is:  216
 Square is:  49
 Cube is:  343
 Square is:  4
 Cube is:  8
 Total time taken by threads is: 1.5140972137451172
 Again executing the main thread
 Thread 1 and Thread 2 have finished their execution.

下一主题Python 中的静态

Python 3 中的多线程