Python 课程8-多线程编程和多进程编程

已于 2024-09-14 21:27:25 修改
阅读量361 收藏 9
点赞数 11
分类专栏： Python教學 文章标签： python 开发语言 threading multiprocessing
于 2024-09-14 20:56:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tim654654/article/details/142266142
版权

前言

        在现代编程中，处理并发任务是提高程序性能的关键之一。Python 提供了 多线程（threading） 和 多进程（multiprocessing） 两种方式来实现并发编程。多线程适用于 I/O 密集型任务，而多进程则更适合 CPU 密集型任务。通过这两种技术，你可以高效地处理大规模数据、加速程序执行并优化资源利用。

        在本篇详细教程中，我们将讨论如何使用 Python 的 threading 模块实现多线程，以及如何使用 multiprocessing 库实现多进程，帮助你掌握并发编程的基础和应用场景。        

目录

1.多线程编程（threading）

  1. 什么是多线程？
  2. 使用 Thread() 创建线程
  3. start() 和 join()：启动和等待线程
  4. 线程间共享数据
  5. 锁（Locks）：避免线程冲突
  6. 示例：多线程处理 I/O 操作

2.多进程编程（multiprocessing）

  1. 什么是多进程？
  2. 使用 Process() 创建进程
  3. 进程池（Pool）管理多个进程
  4. map() 和 apply_async()：并行任务执行
  5. 进程间通信（Queue 和 Pipe）
  6. 示例：多进程计算密集型任务

多线程编程（threading）

1. 什么是多线程？

        多线程是指在一个进程中同时运行多个线程，每个线程执行不同的任务，共享进程的内存空间。多线程适用于I/O密集型任务，如文件读写、网络请求等，可以提高程序的并发性和响应速度。

特点：

  • 共享内存空间，数据共享和通信方便。
  • 线程间切换速度快，开销小。
  • 受全局解释器锁（GIL）影响，CPU密集型任务并不能真正并行。

2. 使用 Thread() 创建线程

threading模块提供了创建线程的类和方法。

import threading  # 导入 threading 模块

def task():
    print("这是一个线程任务")

# 创建线程对象，target参数指定线程要执行的函数
thread = threading.Thread(target=task)

# 启动线程
thread.start()

代码解析：

  • import threading：导入线程模块。
  • def task()：定义线程要执行的函数。
  • threading.Thread(target=task)：创建线程对象。
  • thread.start()：启动线程，开始执行任务。

3. start() 和 join()：启动和等待线程

  • start()：启动线程，使其开始执行。
  • join()：阻塞主线程，等待子线程完成。
import threading
import time

def task(name):
    print(f"线程 {name} 开始")
    time.sleep(2)
    print(f"线程 {name} 结束")

# 创建多个线程
threads = []
for i in range(3):
    thread = threading.Thread(target=task, args=(i,))
    threads.append(thread)
    thread.start()

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

print("所有线程已完成")

 代码解析：

  • args=(i,)：传递参数给线程函数。
  • threads.append(thread)：将线程对象添加到列表中，便于管理。
  • thread.join()：主线程等待子线程完成。

4. 线程间共享数据

线程之间可以共享全局变量，但需要注意线程安全问题。

import threading

counter = 0  # 全局变量

def increment():
    global counter
    for _ in range(100000):
        counter += 1

# 创建两个线程
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)

# 启动线程
thread1.start()
thread2.start()

# 等待线程完成
thread1.join()
thread2.join()

print(f"最终计数器的值为：{counter}")

注意：由于线程争用，最终计数器的值可能不等于预期的200000。这是因为多个线程同时修改共享数据，导致数据竞争。

5. 锁（Locks）：避免线程冲突

使用锁机制可以确保同一时间只有一个线程访问共享数据，避免数据竞争。

import threading

counter = 0
lock = threading.Lock()  # 创建锁对象

def increment():
    global counter
    for _ in range(100000):
        lock.acquire()  # 获取锁
        counter += 1
        lock.release()  # 释放锁

# 创建两个线程
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)

# 启动线程
thread1.start()
thread2.start()

# 等待线程完成
thread1.join()
thread2.join()

print(f"最终计数器的值为：{counter}")

 代码解析：

  • lock = threading.Lock()：创建一个锁对象。
  • lock.acquire()：请求获取锁，若锁已被占用，则等待。
  • lock.release()：释放锁，供其他线程使用。

6. 示例：多线程处理 I/O 操作

import threading
import requests

urls = [
    'https://www.python.org',
    'https://www.google.com',
    'https://www.github.com',
    # 更多的URL
]

def fetch_content(url):
    response = requests.get(url)
    print(f"{url} 的响应码：{response.status_code}")

threads = []
for url in urls:
    thread = threading.Thread(target=fetch_content, args=(url,))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print("所有请求已完成")

 代码解析：

  • requests.get(url)：发送HTTP GET请求。
  • threading.Thread(target=fetch_content, args=(url,))：为每个URL创建一个线程。
  • 适用于I/O密集型任务，提高程序响应速度。

多进程编程（multiprocessing）

1. 什么是多进程？

多进程是指同时运行多个进程，每个进程都有独立的内存空间。多进程适用于CPU密集型任务，如计算、图像处理等，能有效利用多核CPU，提高程序性能。

特点：

  • 进程间内存独立，数据不共享，安全性高。
  • 能够真正实现并行，充分利用多核CPU。
  • 进程创建和切换开销较大。

2. 使用 Process() 创建进程

import multiprocessing

def task(name):
    print(f"进程 {name} 开始")
    # 执行任务
    print(f"进程 {name} 结束")

if __name__ == '__main__':
    process = multiprocessing.Process(target=task, args=('A',))
    process.start()
    process.join()
    print("主进程结束")

 代码解析：

  • multiprocessing.Process(target=task, args=('A',))：创建进程对象。
  • process.start()：启动进程。
  • process.join()：等待进程完成。
  • 注意：在Windows系统中，必须将进程创建代码放在if __name__ == '__main__':下。

3. 进程池（Pool）管理多个进程

import multiprocessing
import time

def task(name):
    print(f"任务 {name} 开始")
    time.sleep(2)
    print(f"任务 {name} 结束")

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=3)  # 创建拥有3个进程的进程池
    for i in range(5):
        pool.apply_async(task, args=(i,))
    pool.close()  # 关闭进程池，不能再添加新任务
    pool.join()   # 等待所有任务完成
    print("所有任务已完成")

 代码解析：

  • multiprocessing.Pool(processes=3)：创建进程池，最大进程数为3。
  • pool.apply_async(task, args=(i,))：异步提交任务到进程池。
  • pool.close()：关闭进程池，不再接受新任务。
  • pool.join()：主进程等待进程池中的任务完成。

4. map() 和 apply_async()：并行任务执行

使用 map() 方法

import multiprocessing

def square(x):
    return x * x

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    results = pool.map(square, range(10))
    print(results)

 代码解析：

  • pool.map(square, range(10))：将range(10)中的每个元素传递给square函数，并行计算。

使用 apply_async() 方法

import multiprocessing

def square(x):
    return x * x

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    results = []
    for i in range(10):
        result = pool.apply_async(square, args=(i,))
        results.append(result)
    pool.close()
    pool.join()
    print([r.get() for r in results])

 代码解析：

  • pool.apply_async()：异步地将任务提交到进程池。
  • result.get()：获取异步执行的结果。

5. 进程间通信（Queue 和 Pipe）

使用 Queue

import multiprocessing

def producer(queue):
    for item in range(5):
        queue.put(item)
        print(f"生产者生产了：{item}")

def consumer(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print(f"消费者消费了：{item}")

if __name__ == '__main__':
    queue = multiprocessing.Queue()
    p = multiprocessing.Process(target=producer, args=(queue,))
    c = multiprocessing.Process(target=consumer, args=(queue,))

    p.start()
    c.start()

    p.join()
    queue.put(None)  # 发送终止信号
    c.join()

 代码解析：

  • multiprocessing.Queue()：创建进程间共享的队列。
  • queue.put(item)：将数据放入队列。
  • queue.get()：从队列中获取数据。

使用 Pipe

import multiprocessing

def sender(conn):
    conn.send("你好，消费者")
    conn.close()

def receiver(conn):
    message = conn.recv()
    print(f"接收到的信息：{message}")

if __name__ == '__main__':
    parent_conn, child_conn = multiprocessing.Pipe()
    s = multiprocessing.Process(target=sender, args=(parent_conn,))
    r = multiprocessing.Process(target=receiver, args=(child_conn,))

    s.start()
    r.start()

    s.join()
    r.join()

 代码解析：

  • multiprocessing.Pipe()：创建一个管道，返回两个连接对象。
  • conn.send()：发送数据。
  • conn.recv()：接收数据。

6. 示例：多进程计算密集型任务

import multiprocessing
import math
import time

def compute(start, end):
    result = 0
    for i in range(start, end):
        result += math.sqrt(i)
    return result

if __name__ == '__main__':
    start_time = time.time()
    cpu_count = multiprocessing.cpu_count()
    pool = multiprocessing.Pool(processes=cpu_count)

    total_numbers = 10000000
    chunk_size = total_numbers // cpu_count
    tasks = []

    for i in range(cpu_count):
        start = i * chunk_size
        end = (i + 1) * chunk_size if i != cpu_count - 1 else total_numbers
        tasks.append(pool.apply_async(compute, args=(start, end)))

    pool.close()
    pool.join()

    total = sum([task.get() for task in tasks])
    print(f"计算结果：{total}")
    print(f"耗时：{time.time() - start_time} 秒")

 代码解析：

  • cpu_count = multiprocessing.cpu_count()：获取CPU核心数。
  • 将计算任务分割成多个子任务，分配给不同的进程执行。
  • pool.apply_async(compute, args=(start, end))：异步提交计算任务。
  • sum([task.get() for task in tasks])：汇总各进程的计算结果。

结论

通过本教程，我们深入学习了Python中的多线程和多进程编程：

  • 多线程编程（threading）：

    • 理解了什么是多线程，以及如何创建和管理线程。
    • 学会了使用锁机制避免线程间的数据竞争。
    • 了解了多线程在I/O密集型任务中的应用。

  • 多进程编程（multiprocessing）：

    • 掌握了多进程的概念，能创建和管理进程。
    • 学习了进程池的使用，提高了多进程编程的效率。
    • 了解了进程间通信的方法，如队列和管道。
    • 认识到多进程在CPU密集型任务中的优势。

        通过合理地使用多线程和多进程，可以显著提升程序的性能和效率。希望本教程能帮助您深入理解并发编程的核心概念，并在实际项目中加以应用。

可愛小吉
关注
专栏目录
Python中的并发编程：多线程与多进程的比较
一键难忘的博客
03-11 3786
在Python编程领域中，处理并发任务是提高程序性能的关键之一。本文将探讨Python中两种常见的并发编程方式：多线程和多进程，并比较它们的优劣之处。通过代码实例和详细的解析，我们将深入了解这两种方法的适用场景和潜在问题。
Python 多线程和多进程用法
日常学习与专研的记录
04-19 1689
本文详细介绍Python的多进程以及多线程的用法，并且结合tqdm进度条展示
Python中的多线程与多进程编程：线程池与进程池的应用
一键难忘的博客
05-23 2833
线程池是一种预先创建一定数量的线程并维护这些线程，以便在需要时重复使用它们的技术。线程池可以减少线程创建和销毁的开销，提高线程的重复利用率。在Python中，可以使用来创建线程池。本文介绍了在Python中使用线程池和进程池来实现并发编程的方法，并提供了相应的代码示例。首先，我们讨论了多线程和多进程的概念及其在并发编程中的应用场景。然后，我们深入探讨了线程池和进程池的工作原理以及它们之间的性能比较。在代码示例部分，我们演示了如何使用线程池和进程池来执行多个任务，其中包括下载多个文件的示例。
python 中的并发编程-多线程编程
qq_42898642的博客
06-13 1357
python中的多线程编程，干货满满哦
python指南之多线程与多进程编程大全
ma_nong33的博客
06-12 1127
Python作为一种高级编程语言，提供了多种并发编程的方式，其中多线程与多进程是最常见的两种方式之一。在本文中，我们将探讨Python中多线程与多进程的概念、区别以及如何使用线程池与进程池来提高并发执行效率。 多线程与多进程的概念 多线程 多线程是指在同一进程内，多个线程并发执行。每个线程都拥有自己的执行栈和局部变量，但共享进程的全局变量、静态变量等资源。多线程适合用于I/O密集型任务，如网络请求、文件操作等，因为线程在等待I/O操作完成时可以释放GIL（全局解释器锁），允许其他线程执行。 多进程
Python多进程并发与多线程并发编程实例总结
09-20
- Python通过内置的threading模块支持多线程编程。 - 通过multiprocessing模块支持多进程编程。 - Python的全局解释器锁（GIL）限制了同一时刻只有一个线程执行Python字节码，对CPU密集型任务不利，但对于IO密集...
python并发编程之多进程、多线程、异步和协程详解
12-25
最近学习python并发，于是对多进程、多线程、异步和协程做了个总结。 一、多线程 多线程就是允许一个进程内存在多个控制权，以便让多个函数同时处于激活状态，从而让多个函数的操作同时运行。即使是单CPU的计算机，...
PYthon-multithreading-Test.rar_python_python 多线程_python多线程_多线程
09-19
本压缩包“PYthon-multithreading-Test.rar”包含了有关Python多线程测试的源码，旨在帮助用户深入理解和实践Python的线程操作。 Python中的多线程是通过`threading`模块实现的，这个模块提供了基本的线程和同步...
Python多线程编程.zip
09-04
Python多线程编程.zipPython多线程编程.zipPython多线程编程.zipPython多线程编程.zipPython多线程编程.zipPython多线程编程.zipPython多线程编程.zipPython多线程编程.zipPython多线程编程.zip 运行python的时候，...
蒙特卡罗方法——布丰投针实验近似计算圆周率python代码实现
2301_79376014的博客
09-09 493
蒙特卡罗——布丰实验
pip-tools：打造可重复、可控的 Python 开发环境，解决依赖关系，让代码更稳定
weixin_53707653的博客
09-09 833
是一个强大且易用的工具，可以帮助开发者轻松管理 Python 项目的依赖关系，确保代码的可重复性和稳定性。是一组命令行工具，旨在简化 Python 依赖关系的管理，确保项目环境的稳定性和可重复性。可以确保每次构建环境时都使用相同的依赖项版本，从而避免由于依赖项版本不一致导致的错误，提高代码可重复性和稳定性。自动化了依赖关系管理过程，节省了开发者的时间和精力，可以将更多时间投入到实际的开发工作中。文件中的信息，更新虚拟环境，安装、升级或卸载所需的软件包，确保虚拟环境与。命令可以从你的项目配置文件中生成。
Python实现多线程、多进程及协程
qq_42568323的博客
09-09 1078
本文详细介绍了 Python 中多线程、多进程和协程的并发模型及其实现方式，并通过具体场景演示了如何使用面向对象思想实现这些模型。在实际应用中，应根据任务的类型和需求选择合适的并发模型，从而优化程序的性能和资源利用率。本文将详细介绍 Python 中的多线程、多进程和协程的概念及其实现方式，并通过具体场景展示如何在 Python 中使用面向对象的思想实现这些并发模型。接下来，我们通过一个计算密集型任务的示例来演示多进程的实现：计算一系列大数字的阶乘。主程序中创建并启动了多个计算进程，并使用。
[Python]生成器和yield关键字
weixin_57336987的博客
09-07 442
概述:​ 它指的是 generator, 类似于以前学过的: 列表推导式, 集合推导式, 字典推导式…作用:​ 降低资源消耗, 快速(批量)生成数据.实现方式:​ 1.推导式写法.​ 2.yield写法.yield i # yield会记录每个生成的数据, 然后逐个的放到生成器对象中, 最终返回生成器对象.问题: 如何从生成器对象中获取数据?​ 答案:​ 1.for循环遍历​ 2.next()函数, 逐个获取.
Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警
最新发布
weixin_50556117的博客
09-11 1032
【代码】Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警。
程序的格式框架与缩进
qq_57335683的博客
09-08 376
在上一课时中，我们介绍了 Python 的基本概念，并成功运行了第一个 Python 程序。本课时将深入探讨 Python 程序的基本结构、缩进的重要性，以及如何正确使用注释。通过本课时的学习，你将更好地理解 Python 代码的组织方式，并能够避免一些常见的编程错误。通过本课时的学习，你了解了 Python 程序的基本结构，认识到缩进在 Python 中的重要性，并学会了如何避免常见的缩进错误。缩进不仅是 Python 代码风格的一部分，而且是语法的一部分。这意味着如果缩进不正确，程序将无法正常运行。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 618
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
Python 检测人脸筛选指定尺寸人脸图片
刚刚入门的小码农
09-09 664
主要功能是处理一个指定文件夹中的所有图像文件（.jpg和.png），并根据图像中检测到的人脸特征，筛选和移动符合条件的图像。
JIT编译器
Flying_Fish_roe的博客
09-11 546
JIT（Just-In-Time，实时编译）编译器是 Java 虚拟机（JVM）中的一项重要技术，用于将 Java 字节码（Bytecode）在运行时动态编译为机器码。Java 程序最初通过编译器（如javac）将源代码编译为字节码，字节码在 JVM 中解释执行。然而，由于解释执行每次都需要逐条翻译字节码指令为机器指令，这种方式效率较低。为了解决性能问题，JIT 编译器在程序运行时将热点代码编译为机器码，从而提高运行效率。JIT 编译器是 Java“编译型”和“解释型”语言的结合特性的重要体现之一。
【AIGC】对AI编程常用的工具提供简要介绍和应用场景
weixin_51306394的博客
09-08 1698
I编程工具的选择和使用对于构建高效的机器学习和深度学习系统至关重要。这些工具涵盖了从数据处理、模型训练、模型优化到模型部署的各个环节。下面是一个全面的AI编程工具合集，按功能分类列出了一些常用的工具，并提供了简要介绍和应用场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值