「多线程大杀器」Python并发编程利器:ThreadPoolExecutor,让你一次性轻松开启多个线程,秒杀大量任务!

简介: 「多线程大杀器」Python并发编程利器:ThreadPoolExecutor,让你一次性轻松开启多个线程,秒杀大量任务!

随着程序复杂度和数据量的不断增加,传统的同步编程方式已经无法满足开发人员的需求。异步编程随之产生,能够提供更高的并发性能和更好的资源利用率。Python的concurrent.futures模块是一个很好的异步编程工具,它提供了一组接口,可以方便地进行并发编程。


Python中已经有了threading模块,为什么还需要这些线程池、进程池处理呢?以Python爬虫为例,需要控制同时爬取的线程数,比如我们创建了20甚至100个线程,而同时只允许5-10个线程在运行,但是20-100个线程都需要创建和销毁,线程的创建是需要消耗系统资源的,有没有更好的方案呢?


其实只需要同时创建运行5-10个线程就可以,每个线程各分配一个任务,剩下的任务排队等待,当某个线程完成了任务的时候,排队任务就可以安排给这个线程继续执行。

然而自己编写线程池很难写的比较完美,还需要考虑复杂情况下的线程同步,很容易发生死锁。而从Python3.2 开始,标准库为我们提供了concurrent.futures模块,它提供了ThreadPoolExecutorProcessPoolExecutor两个类,实现了对 threadingmultiprocessing 的进一步抽象,不仅可以帮我们自动调度线程,还可以做到:

  • 主线程可以获取某一个线程(或者任务的)的状态,以及返回值。
  • 当一个线程完成的时候,主线程能够立即知道。
  • 让多线程和多进程的编码接口一致。


简介


concurrent.futures 模块是 Python3.2 中引入的新模块,用于支持异步执行,以及在多核CPU和网络I/O中进行高效的并发编程。这个模块提供了ThreadPoolExecutor和ProcessPoolExecutor两个类,简化了跨平台异步编程的实现。


首先,让我们先来理解两种并发编程的方式:


1、多进程

当通过多进程来实现并发编程时,程序会将任务分配给多个进程,这些进程可以在不同的CPU上同时运行。进程之间是独立的,各自有自己的内存空间等,可以实现真正的并行执行。不过,进程之间的通信比较耗时,需要使用IPC(进程间通信)机制,而且进程之间的切换比线程之间的切换耗时,所以创建进程的代价较高。


2、多线程

当通过多线程来实现并发编程时,程序会将任务分配给多个线程,这些线程可以在同一个进程中的不同CPU核上同时运行。线程之间共享进程的内存空间,因此开销比较小。但是需要注意,在Python解释器中,线程是无法实现真正的并行执行,因为Python有GIL(全局解释器锁),它确保同时只有一个线程运行Python代码。因此,一个Python进程中的多个线程并不能并行执行,在使用多线程编程时不能完全利用多核CPU。


简单使用(案例及使用参数说明)


concurrent.futures 是Python中执行异步编程的重要工具,它提供了以下两个类:


1、ThreadPoolExecutor


ThreadPoolExecutor 创建一个线程池,任务可以提交到这个线程池中执行。ThreadPoolExecutorProcessPoolExecutor 更容易使用,且没有像进程那样的开销。它可以让我们在一个Python解释器中进行跨线程异步编程,因为它规避了GIL。


示例:

from concurrent.futures import ThreadPoolExecutor
def test(num):
    print("Threads" num)
# 新建ThreadPoolExecutor对象并指定最大的线程数量
with ThreadPoolExecutor(max_workers=3) as executor:
    # 提交多个任务到线程池中
    executor.submit(test, 1)
    executor.submit(test, 2)
    executor.submit(test, 3)

输出结果:

Thread 1
Thread 2
Thread 3

2、ProcessPoolExecutor


ProcessPoolExecutor 创建一个进程池,任务可以提交到这个进程池中执行。当对于单个任务的处理开销很大,例如大规模计算密集型应用,应该使用这个线程池。


示例:

from concurrent.futures import ProcessPoolExecutor
def test(num):
    print("Processs" num)
# 新建ProcessPoolExecutor对象并指定最大的进程数量
with ProcessPoolExecutor(max_workers=3) as executor:
    # 提交多个任务到进程池中
    executor.submit(test, 1)
    executor.submit(test, 2)
    executor.submit(test, 3)

输出结果:

Process 2
Process 1
Process 3

等待任务完成


1、ThreadPoolExecutor构造实例的时候,传入max_workers参数来设置线程池中最多能同时运行的线程数目。

2、使用submit函数来提交线程需要执行的任务(函数名和参数)到线程池中,并返回该任务的句柄,注意submit()不是阻塞的,而是立即返回。

3、通过submit函数返回的任务句柄,能够使用done()方法判断该任务是否结束。

4、使用cancel()方法可以取消提交的任务,如果任务已经在线程池中运行了,就取消不了。

5、使用result()方法可以获取任务的返回值。查看内部代码,发现这个方法是阻塞的。

在提交任务之后,我们通常需要等待它们完成,可以使用如下方法:


1、result()

用于获取 submit() 方法返回的 Future 对象的结果。该方法是同步的,Block主线程,直至得到结果或者抛异常。


示例:

from concurrent.futures import ThreadPoolExecutor
def test(num):
    print("Tasks" num)
# 新建ThreadPoolExecutor对象并指定最大的线程数量
with ThreadPoolExecutor(max_workers=3) as executor:
    # 提交多个任务到线程池中,并使用result方法等待任务完成
    future_1 = executor.submit(test, 1)
    future_2 = executor.submit(test, 2)
    future_3 = executor.submit(test, 3)
    print(future_1.result())

输出:

Task 1
Task 2
Task 3
None

2、add_done_callback()


给每个 submit() 返回的 Future 对象添加一个“完成时”的回调函数。主线程运行完毕而不需要等待任务完成,这个回调函数会在任务完成时自动执行。


示例:

from concurrent.futures import ThreadPoolExecutor
def callback(future):
    print("Task done? ", future.done())
    print("Result: ", future.result())
# 新建ThreadPoolExecutor对象并指定最大的线程数量
with ThreadPoolExecutor(max_workers=3) as executor:
    # 提交多个任务到线程池中,并添加“完成时”回调函数
    future_1 = executor.submit(pow, 2, 4)
    future_2 = executor.submit(pow, 3, 4)
    callback_future_1 = executor.submit(callback, future_1)

ThreadPoolExecutor类常用方法


ThreadPoolExecutorProcessPoolExecutor类下方法名大多都是同样的,只不过因为一个是线程方式、一个是进程方式,底层逻辑实现可能不同。由于我们在日常开发过程中,线程 ThreadPoolExecutor 使用的较多,所以以 ThreadPoolExecutor 为主要使用对象进行说明讲解


当使用 ThreadPoolExecutor 创建的线程池对象后,我们可以使用 submitmapshutdown等方法来操作线程池中的线程以及任务。


1、submit方法


ThreadPoolExecutorsubmit方法用于将任务提交到线程池中进行处理,该方法返回一个Future对象,代表将来会返回结果的值。submit方法的语法如下:

submit(fn, *args, **kwargs)

其中,fn参数是要执行的函数,*args**kwargs是fn的参数。


示例:

from concurrent.futures import ThreadPoolExecutor
def multiply(x, y):
    return x * y
with ThreadPoolExecutor(max_workers=3) as executor:
    future = executor.submit(multiply, 10, 5)
    print(future.result()) # 50

2、map方法


ThreadPoolExecutormap方法用于将函数应用于迭代器中的每个元素,该方法返回一个迭代器。map方法的语法如下:

map(func, *iterables, timeout=None, chunksize=1)

其中,func参数是要执行的函数,*iterables是一个或多个迭代器,timeoutchunksize是可选参数。


示例:

from concurrent.futures import ThreadPoolExecutor
def square(x):
    return x * x
def cube(x):
    return x * x * x
with ThreadPoolExecutor(max_workers=3) as executor:
    results = executor.map(square, [1, 2, 3, 4, 5])
    for square_result in results:
        print(square_result)
    results = executor.map(cube, [1, 2, 3, 4, 5])
    for cube_result in results:
        print(cube_result)

3、shutdown方法


ThreadPoolExecutorshutdown方法用于关闭线程池,该方法在所有线程执行完毕后才会关闭线程池。shutdown方法的语法如下:

shutdown(wait=True)

其中,wait参数表示是否等待所有任务执行完毕后才关闭线程池,默认为True


示例:

from concurrent.futures import ThreadPoolExecutor
import time
def task(num):
    print("Task {} is running".format(num))
    time.sleep(1)
    return "Task {} is complete".format(num)
with ThreadPoolExecutor(max_workers=3) as executor:
    futures = [executor.submit(task, i) for i in range(1, 4)]
    executor.shutdown()


源码分析


cocurrent.future模块中的future的意思是未来对象,可以把它理解为一个在未来完成的操作,这是异步编程的基础 。在线程池submit()之后,返回的就是这个future对象,返回的时候任务并没有完成,但会在将来完成。也可以称之为任务的返回容器,这个里面会存储任务的结果和状态。


那ThreadPoolExecutor内部是如何操作这个对象的呢?下面简单介绍 ThreadPoolExecutor 的部分代码:

1、init方法

init方法中主要重要的就是任务队列和线程集合,在其他方法中需要使用到。

image.png

init源码解析


2、submit方法


submit中有两个重要的对象,_base.Future()_WorkItem()对象,_WorkItem()对象负责运行任务和对**future对象进行设置,最后会将future对象返回,可以看到整个过程是立即返回的,没有阻塞。

image.png

submit源码解析


总结


在Python asyncio模块的基础之上,concurrent.futures模块为Python提供了一种简单高效的异步编程方式,它支持同步、线程、进程等多种并发执行方式,为开发人员提供了更加灵活高效的并发解决方案。我们可以使用submit、map、shutdown等方法来操作线程池中的线程以及任务,使用Future对象(异步编程的核心)来管理任务状态,更加方便地进行任务提交、状态管理和线程池的管理和控制。


在实际开发过程中,我们需要根据具体的应用场景,选择适当的异步编程工具和方式,以获得更好的效果。总之,concurrent.futures模块是Python异步编程中一个非常好的利器。

相关文章
|
3天前
|
安全 Java 关系型数据库
多线程(线程安全)
多线程(线程安全)
14 4
|
3天前
|
Java 调度
多线程(创建多线程的五种方式,线程状态, 线程中断)
多线程(创建多线程的五种方式,线程状态, 线程中断)
13 0
|
3天前
|
Linux 调度 Windows
【操作系统】线程、多线程模型
【操作系统】线程、多线程模型
13 1
|
3天前
|
并行计算 Python
Python并发编程与多线程
Python编程中,多线程和并发编程是优化复杂任务执行的关键。借助标准库中的`threading`模块,可实现多线程,如示例所示,创建线程并执行函数。然而,由于全局解释器锁(GIL),多线程在CPU密集型任务中并不高效。对于I/O密集型任务,多线程仍能提高效率。为充分利用多核,可采用多进程(如`multiprocessing`模块)或异步编程。选择技术时需依据任务类型和性能需求。
|
3天前
|
Java 调度
多线程的基本概念和实现方式,线程的调度,守护线程、礼让线程、插入线程
多线程的基本概念和实现方式,线程的调度,守护线程、礼让线程、插入线程
13 0
|
3天前
|
消息中间件 安全 调度
基于Python的性能优化(线程、协程、进程)
一、多线程 在CPU不密集、IO密集的任务下,多线程可以一定程度的提升运行效率。
|
4天前
|
设计模式 安全 Java
Java多线程案例-Java多线程(3)
Java多线程案例-Java多线程(3)
8 1
|
4天前
|
存储 安全 Java
Java多线程安全风险-Java多线程(2)
Java多线程安全风险-Java多线程(2)
9 1
|
4天前
|
Java 调度
聊聊Java线程是个啥东西-Java多线程(1)
聊聊Java线程是个啥东西-Java多线程(1)
11 0
|
4天前
|
NoSQL Java 关系型数据库
实时计算 Flink版产品使用合集之实现存量读取时采用多线程、增量读取时采用单线程如何解决
实时计算Flink版作为一种强大的流处理和批处理统一的计算框架,广泛应用于各种需要实时数据处理和分析的场景。实时计算Flink版通常结合SQL接口、DataStream API、以及与上下游数据源和存储系统的丰富连接器,提供了一套全面的解决方案,以应对各种实时计算需求。其低延迟、高吞吐、容错性强的特点,使其成为众多企业和组织实时数据处理首选的技术平台。以下是实时计算Flink版的一些典型使用合集。