Python教程-Python 3中的多线程

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

Python 3中的多线程

Python多线程

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

注意：Python全局解释器锁（GIL）允许一次只运行一个线程，即使机器有多个处理器也是如此。

使用Python进行多线程的优势

使用Python进行多线程的优势如下：

1. 它保证了计算机系统资源的有效使用。
2. 具有多个线程的应用程序响应更快。
3. 它更具成本效益，因为它与子线程（子线程）共享资源和状态。
4. 由于亲密度，多处理器架构更加有效。
5. 通过同时运行多个线程，可以节省时间。
6. 系统不需要大量内存来存储多个线程。

何时在Python中使用多线程？

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

如何在Python中实现多线程？

在处理Python中的线程的两个主要模块有：

1. 线程模块
2. 线程模块

线程模块

从Python 3开始，线程模块已被标记为过时，并且只能通过支持向后兼容性的 _thread 访问。

语法：

thread.start_new_thread ( function_name, args[, kwargs] )  

要在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

线程模块

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

线程类方法

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

要在Python多线程中实现线程模块，请按照以下步骤操作：

1. 导入线程模块

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

语法：

import threading  

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

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

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

例如：

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

在上述代码中，我们将 print_hello() 函数作为目标参数调用。 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.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.