Python多线程、多进程和线程池

多线程与线程池的深入对比

多线程是一种并发编程模型，允许一个程序同时执行多个任务。每个任务由一个独立的线程执行，线程共享进程的内存空间，但拥有自己的程序计数器、寄存器组和栈。

线程池是一种线程管理技术，它预先创建一定数量的线程，并将这些线程放入一个池中。当有新的任务需要执行时，线程池会从池中取出一个空闲的线程来执行任务，任务执行完毕后，线程并不会被销毁，而是返回线程池中等待下一个任务。

多进程在Python中，多进程指的是同时运行多个进程。每个进程都有独立的内存空间，可以并行执行不同的任务。相比于多线程，多进程更加稳定，因为一个进程崩溃不会影响其他进程

核心区别

特征 多进程 多线程 线程池
内存空间 独立 共享 共享
创建开销 大 小 小
通信方式 IPC（管道、队列等） 共享变量 共享变量
GIL影响 无 受GIL影响（Python） 受GIL影响（Python）
稳定性 高 相对较低（一个线程崩溃可能影响整个进程） 相对较高（线程池可以管理线程生命周期）
适用场景 CPU密集型任务，需要高稳定性 I/O密集型任务，需要共享数据 I/O密集型任务，需要控制并发数

优势对比

特征 多进程 多线程 线程池
优势 稳定性高，充分利用多核CPU 创建开销小，共享数据方便 提高响应速度，降低资源消耗，管理方便
劣势 创建开销大，通信复杂 GIL限制并发性，线程安全问题 需要合理配置参数

线程池的参数配置

  • corePoolSize: 核心线程数，即常驻的线程数。
  • maximumPoolSize: 最大线程数，即线程池中允许的最大线程数。
  • keepAliveTime: 空闲线程存活时间，超过这个时间，空闲线程会被销毁。
  • workQueue: 任务队列，用于存放等待执行的任务。

选择多线程、多进程还是线程池

  • 任务数量较少，生命周期较短，对并发性要求不高： 直接使用多线程。
  • 任务数量较多，生命周期较长，对并发性要求高，需要控制资源消耗： 使用线程池。
  • 任务类型多样，计算量较大： 使用多个线程池进行隔离。
  • 任务之间有依赖关系： 使用线程池结合任务队列。

优先考虑线程池： 线程池提供了更灵活、高效的线程管理方式，可以更好地适应各种场景。 在实际开发中，可以根据系统的运行情况对线程池的参数进行调整，以达到最佳的性能。

案例

多线程案例（Python）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import threading

def worker(num):
    """工作线程函数"""
    print(f"Worker {num} started")
    # 模拟任务执行
    import time
    time.sleep(2)
    print(f"Worker {num} finished")

if __name__ == '__main__':
    threads = []
    for i in range(5):
        t = threading.Thread(target=worker, args=(i,))
        threads.append(t)
        t.start()

    # 等待所有线程完成
    for t in threads:
        t.join()

解释：

  1. 创建线程：
    • 对于每个任务，我们创建一个新的 threading.Thread 对象。
    • target 参数指定线程执行的函数（即 worker 函数）。
    • args 参数传递给 worker 函数的参数。
  2. 启动线程：
    • 调用 start() 方法启动线程，使线程开始执行。
  3. 等待线程完成：
    • 调用 join() 方法等待线程执行完毕。

这个例子中，我们创建了5个线程，每个线程执行一个简单的任务（模拟任务执行）。

线程池案例（Python）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import concurrent.futures

def worker(num):
    """工作线程函数"""
    print(f"Worker {num} started")
    # 模拟任务执行
    import time
    time.sleep(2)
    print(f"Worker {num} finished")

if __name__ == '__main__':
    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
        futures = [executor.submit(worker, i) for i in range(5)]
        for future in concurrent.futures.as_completed(futures):
            print(future.result())

解释：

  1. 创建线程池：
    • concurrent.futures.ThreadPoolExecutor 创建一个线程池，max_workers=3 表示最多同时有3个线程执行任务。
  2. 提交任务：
    • executor.submit() 将任务提交给线程池。
  3. 获取结果：
    • concurrent.futures.as_completed() 按完成顺序获取任务的结果。

这个例子中，我们创建了一个最大线程数为3的线程池。即使我们提交了5个任务，同时执行的线程也不会超过3个。线程池会自动管理线程的创建、复用和销毁。

多进程示例(Python)

1
2
3
4
5
6
7
8
import multiprocessing

def task(name):
    print(f"Hello, {name} from {multiprocessing.current_process().name}")

if __name__ == '__main__':
    with multiprocessing.Pool() as p:
        p.map(task, ['Alice', 'Bob', 'Charlie'])

多进程

Python的multiprocessing模块提供了和threading模块类似的API，可以方便地创建和管理进程。

常用方法

  • Process： 创建一个进程对象。
  • Pool： 创建一个进程池，可以同时运行多个进程。
  • Queue： 用于进程之间的通信。
  • Pipe： 用于创建管道，实现进程之间的双向通信。
  • Manager： 用于创建共享的Python对象，如列表、字典等。

多进程与多线程的区别

特征 多进程 多线程
内存空间 独立 共享
创建开销 大 小
通信方式 IPC（管道、队列、共享内存） 共享变量
GIL影响 无 有
稳定性 高 相对较低
适用场景 CPU密集型任务 I/O密集型任务

多进程的应用场景

  • CPU密集型任务： 如科学计算、图像处理等。
  • 独立任务： 每个任务之间没有关联，可以并行执行。
  • 需要高稳定性的任务： 一个进程崩溃不会影响其他进程。

多线程和线程池的区别

  • 线程创建和销毁： 多线程每次任务都需要创建一个新的线程，线程池则复用线程，减少了创建和销毁的开销。
  • 并发控制： 线程池可以控制最大并发数，避免系统资源耗尽。
  • 任务管理： 线程池提供了更方便的接口来管理任务，如提交任务、获取结果等。

原理

多线程

多线程是指在一个程序中同时执行多个任务。这些任务之间可以共享相同的内存空间，但拥有各自的执行路径。形象地说，就像在一个工厂里，多个工人同时在不同的机器上工作，但他们共用同一个车间。

操作系统对线程的支持

操作系统是多线程的核心，它提供了一套机制来管理和调度线程。

  • 线程的创建和销毁： 当一个进程启动时，至少会创建一个主线程。操作系统会为每个线程分配一个唯一的线程标识符（TID），并为其分配所需的资源（如栈空间）。当线程结束时，操作系统会回收这些资源。
  • 线程调度： 操作系统会根据一定的调度算法（如时间片轮转、优先级调度）来决定哪个线程获得CPU的使用权。
  • 线程同步： 操作系统提供了一系列同步原语（如互斥锁、信号量）来协调多个线程之间的访问，防止数据竞争。
  • 线程通信： 线程之间可以通过共享内存或消息传递的方式进行通信。

多线程的底层实现

  • 上下文切换：

    • 当操作系统需要从一个线程切换到另一个线程时，它需要保存当前线程的执行状态（包括程序计数器、寄存器等），然后加载新线程的执行状态。这个过程称为上下文切换。
    • 上下文切换是比较耗时的操作，频繁的上下文切换会降低系统的性能。

  • 线程调度算法：

    • 时间片轮转： 将处理器时间分成若干个时间片，每个线程轮流占用一个时间片。
    • 优先级调度： 根据线程的优先级来分配处理器时间。
    • 多级反馈队列调度： 结合了时间片轮转和优先级调度，可以更好地处理不同类型的线程。

  • 同步原语：

    • 互斥锁： 确保同一时刻只有一个线程可以访问共享资源。
    • 信号量： 控制多个线程对共享资源的访问。
    • 条件变量： 允许线程等待某个条件的发生。

线程池

线程池是一种管理线程的工具，它预先创建一定数量的线程，并将这些线程放入一个池中。当有新的任务需要执行时，线程池会从池中取出一个空闲的线程来执行任务，而不是每次都新建一个线程。任务执行完毕后，线程并不会被销毁，而是返回线程池中等待下一个任务。Python的concurrent.futures模块提供了ThreadPoolExecutor类来实现线程池

线程池的工作原理

  1. 创建线程池： 在程序启动时，创建一个线程池，指定线程池中线程的数量等参数。
  2. 提交任务： 当有新的任务需要执行时，将任务提交给线程池。
  3. 任务分配： 线程池会从队列中取出一个任务，分配给空闲的线程执行。
  4. 线程执行： 线程执行任务。
  5. 任务完成： 任务执行完成后，线程返回线程池中，等待下一个任务。

线程池的组成

  • 线程工作队列： 用于存放待执行的任务。
  • 线程池管理器： 用于创建、管理和回收线程，分配任务。
  • 工作线程： 线程池中实际执行任务的线程。

好的，我将尝试将关于多进程的底层原理的解释变得更加专业和深入。

多进程

进程的本质与创建

  • 进程控制块（PCB）：操作系统为每个进程维护一个PCB，其中包含了进程的标识信息（PID）、状态（运行、就绪、阻塞等）、内存地址、CPU寄存器、文件描述符、信号处理函数等。PCB是操作系统管理进程的唯一依据。
  • 地址空间：每个进程都有独立的虚拟地址空间，保证了进程之间内存的隔离。操作系统通过页表机制将虚拟地址映射到物理内存。
  • 进程创建：操作系统在创建进程时，会为新进程分配一个唯一的PID，复制父进程的PCB（部分信息可能需要修改），并为新进程分配独立的地址空间。

进程调度与上下文切换

  • 进程调度：操作系统根据一定的调度算法（如FCFS、SJF、优先级调度、时间片轮转等）来决定哪个就绪进程获得CPU的使用权。
  • 上下文切换：当操作系统从一个进程切换到另一个进程时，需要保存当前进程的执行状态（包括程序计数器、寄存器、栈指针等），然后加载新进程的执行状态。上下文切换是比较耗时的操作。

进程同步与通信

  • 进程同步：多个进程在并发执行时，为了保证数据的一致性，需要进行同步。常用的同步机制有信号量、互斥锁、条件变量等。
  • 进程通信：进程之间可以通过管道、消息队列、共享内存、信号等方式进行通信。

内存管理

  • 虚拟内存：操作系统为每个进程提供了一个虚拟的连续地址空间，通过页表机制将其映射到物理内存。
  • 页表：页表是一个数据结构，用于记录虚拟地址和物理地址之间的映射关系。
  • 分页：将进程的虚拟地址空间划分为固定大小的页，物理内存也划分为相同大小的页框。

进程状态

  • 运行态：进程正在占用CPU运行。
  • 就绪态：进程具备运行条件，但由于没有获得CPU，处于等待状态。
  • 阻塞态：进程正在等待某个事件发生（如I/O操作完成），无法运行。

多进程的优势与劣势

  • 优势：
    • 稳定性高：一个进程崩溃不会影响其他进程。
    • 充分利用多核CPU：多个进程可以并行执行。
    • 内存隔离：每个进程都有独立的内存空间。
  • 劣势：
    • 创建进程开销大：创建进程需要分配资源、初始化PCB等。
    • 进程间通信复杂：进程间通信需要使用特定的机制。

多进程的应用场景

  • CPU密集型任务：如科学计算、图像处理等。
  • 独立任务：每个任务之间没有关联，可以并行执行。
  • 需要高稳定性的任务：一个进程崩溃不会影响其他进程。

总结

多进程、多线程和线程池各有优缺点，选择合适的并发模型取决于具体的应用场景。在实际开发中，可以根据需要结合使用这些并发模型。

Python
Python多线程、多进程和线程池
https://chrrr1y.github.io/2024/08/15/Python多线程和线程池/
作者
Chrrr1y
发布于
2024年8月15日
更新于
2024年8月15日
许可协议