Python3中的多线程编程|极客笔记

Python3中的多线程编程

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

Python 3中的多线程

Python多线程

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

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

使用Python进行多线程的优点

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

保证了计算机系统资源的有效使用。
具有多个线程的应用程序反应更快。
它更具成本效益，因为它与子线程共享资源和状态。
由于亲近，多处理器架构更具可行性。
通过同时运行多个线程，可以缩短时间。
系统不需要大量内存来存储多个线程。

何时在Python中使用多线程

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

如何在Python中实现多线程

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

线程模块
线程模块

线程模块

它与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程序中导入线程模块。

线程类方法

方法	描述
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.