python并发编程

已于 2022-10-22 15:34:49 修改
阅读量387 收藏
点赞数
分类专栏： 笔记 文章标签： python 开发语言
于 2022-10-22 15:32:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57486465/article/details/127462568
版权

1. CPU密集型、I/O密集型?

博客地址:https://www.cxy96.top/
CPU密集型

  • CPU密集型也叫计算密集型，是指I/O在很短的时间就可以完成，CPU需要大量的计算和处理，特点是CPU占用率相当高
  • 例如：压缩解压缩、加密解密、正则表达式搜索

I/O密集型

  • I/O密集型指的是系统运作大部分的状况是CPU在I/O(硬盘/内存)的读/写操作，CPU占用率仍然较低。
  • 文件处理程序、网络爬虫程序、读写数据库程序

2. 多种并发方式对比

多进程

  1. 优点：可以利用多核CPU并行运算
  2. 缺点：占用资源最多，可启动数目比线程少
  3. 适用于：CPU密集型计算

多线程

  1. 优点：相比进程，更轻量级，占用资源少

  2. 缺点：

    • 相比进程：多线程只能并发执行，不能利用多CPU（GIL)

    • 相比协程：启动数目有限制，占用内存资源，有线程切换开销

  3. 适用于：I/O密集型计算

多协程

  1. 优点：内存开销最少、启动协程数量最多
  2. 缺点：支持的库有限制(aiohttp vs requests)、代码实现复杂
  3. 适用于：I/O密集型计算 但有现成库支持的场景

3. python运行慢的原因

GIL运行机制

  1. 全局解释器锁(Global Interpreter Lock)

    • 每一个线程在开始执行时，都会锁住 GIL，以阻止别的线程执行；同样的，每一个线程执行完一段后，会释放 GIL，以允许别的线程开始利用资源。
    • 导致了python的多线程是伪多线程，不能同时调用多个线程

  2. Python是解释型语言而不是编译型语言

    • 程序不需要编译，程序在运行时才翻译成机器语言，每执 行一次都要翻译一次。因此效率比较低

  3. Python是一门动态类型的语言

    • 运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。

4. 代码实现

多进程

  • 创建进程方式

    import multiprocessing
# 创建一个进程
process1 = multiprocessing.Process(target=函数名,args=(参数1,)) #(参数1)是字符串 (参数1,)是元组
# 执行进程
process1.start()
# 等待子进程结束，才继续执行主进程下面的代码
process1.join()

  • 多进程示例

    import multiprocessing
# 进程列表放置进程
processes = []
# 创建十个进程
for i in range(10):
    processes.append(
        multiprocessing.Process(target=函数名,args=(参数1,)) #(参数1)是字符串 (参数1,)是元组
    )
# 执行线程
for process in processes:
    process.start()
for process in processes:
    process.join()

  • 进程池

    from concurrent.futures import ProcessPoolExecutor
# 第一种map方法按顺序返回  max_workers 指定最大进程数
# 只能传递一个参数
with ProcessPoolExecutor(max_workers=5) as pool:
    results=pool.map(函数名,[线程1参数,线程2参数])
    #每个参数对应一个线程 map一下子执行 返回顺序按参数顺序
    for result in results:
        print(result)

# 第二种as_completed 方法 先执行完先返回
from concurrent.futures import ProcessPoolExecutor,as_completed
with ProcessPoolExecutor() as pool:
    futures=[pool.submit(函数名,参数) for 参数 in 参数列表]
    # 按顺序返回
    for future in futures:
        print(future.result())
    # 先执行完先返回
    for future in as_completed(futures):
        print(result)

多线程

  • 创建线程方式

    import threading
# 创建一个线程
thread1 = threading.Thread(target=函数名,args=(参数1,)) #(参数1)是字符串 (参数1,)是元组
# 执行线程
thread1.start()
# 等待子线程结束，才继续执行下面的代码
thread1.join()

  • 多线程示例

    import threading
# 线程列表放置线程
threads = []
# 创建一千个线程
for i in range(1000):
    threads.append(
        threading.Thread(target=函数名,args=(参数1,)) #(参数1)是字符串 (参数1,)是元组
    )
# 执行线程
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()

  • 线程池管理

    优点：

    1. 提升性能：因为减去了大量新建、终止线程的开销，重用了线程资源；
    2. 适用场景：适合处理突发性大量请求或需要大量线程完成任务、但实际任务处理时间较短
    from concurrent.futures import ThreadPoolExecutor
# 第一种map方法按顺序返回  max_workers 指定最大线程数
# 只能传递一个参数
with ThreadPoolExecutor(max_workers=5) as pool:
    results=pool.map(函数名,[线程1参数,线程2参数])
    #每个参数对应一个线程 map一下子执行 返回顺序按参数顺序
    for result in results:
        print(result)

# 第二种as_completed 方法 先执行完先返回
from concurrent.futures import ThreadPoolExecutor,as_completed
with ThreadPoolExecutor() as pool:
    futures=[pool.submit(函数名,参数) for 参数 in 参数列表]
    # 按顺序返回
    for future in futures:
        print(future.result())
    # 先执行完先返回
    for future in as_completed(futures):
        print(result)

多协程

实现：

import asyncio

# 获取事件循环
loop = asyncio.get_event_loop()

# 定义协程
async def func(参数):
    await func2(参数)

# 创建task列表
tasks = [loop.create_task(func(参数)) for 参数 in 参数列表]

# 执行事件列表
loop.run_until_complete(asyncio.wait(tasks))

5. 高阶应用

5.1 多组件Pipeline架构

使复杂的程序，分为多个中间步骤完成

实现:

import queue
# 1.创建Queue对象 入参 maxsize 是一个整数，如果 maxsize 设置为小于或等于零，则队列的长度没有限制。
q = queue.Queue(maxsize=0)
# 2.添加元素(空间不足时会阻塞)
q.put(item)
# 3.获取元素(没有数据时会阻塞)
item = q.get()
# 4.状态查询
#  查看元素数量
q.qsize()
#  判断是否为空
q.empty()
#  判断是否已满
q.full()

示例:

import queue
q = queue.Queue()  # 创建 Queue 队列
for i in range(3):
    q.put(i)  # 在队列中依次插入0、1、2元素
for i in range(3):
    print(q.get())  # 依次从队列中取出插入的元素，数据元素输出顺序为0、1、2

5.2 线程安全

线程安全是指某个函数、函数库在多线程环境中被调用时，能正确处理多个线程之间的共享变量，使程序功能正常完成

不安全示例:

import time
import threading

class Account:
    def __init__(self,balance):
        self.balance=balance
def draw(account,amount):
    if account.balance>=amount:
        time.sleep(0.1)
        account.balance-=amount
        print("取钱成功，当前账户余额:",account.balance)
    else:
        print("取钱失败,当前账户余额不足")
if __name__=="__main__":
    account=Account(1000)
    t1=threading.Thread(target=draw,args=(account,600))
    t2=threading.Thread(target=draw,args=(account,600))
    t1.start()
    t2.start()

输出结果：

取钱成功，当前账户余额: 400
　　取钱成功，当前账户余额: -200

解决方式：线程锁

import threading
# 方式一：with模式
lock=threading.Lock()
with lock:
    #do something
    
# 方式二：try-finally
lock=threading.Lock()
lock.acquire()
try:
    #do something
finally:
    #执行完释放锁
    lock.release()

加锁后程序：

import threading
import time

lock=threading.Lock()
class Account:
    def __init__(self,balance):
        self.balance=balance
def draw(account,amount):
    #即使切换线程但是锁没释放依然不能运行
    with lock:
        if account.balance>=amount:
            time.sleep(0.1)
            account.balance-=amount
            print("取钱成功，当前账户余额:",account.balance)
        else:
            print("取钱失败,当前账户余额不足")
if __name__=="__main__":
    account=Account(1000)
    t1=threading.Thread(target=draw,args=(account,600))
    t2=threading.Thread(target=draw,args=(account,600))
    t1.start()
    t2.start()

输出结果：

取钱成功，当前账户余额: 400
　　取钱失败,当前账户余额不足

旅程@.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python线程池实现的进阶知识
m0_57021623的博客
12-30 1519
根据具体的情况，你可以根据系统资源和任务需求来调整最大工作线程数。并行执行OCR识别和文件校验：对于不同的PDF文件，可以同时进行OCR识别和文件校验的操作，而不是等待一个文件处理完再处理下一个文件。有几万条数据，如果单个数据处理挨个处理的话，涉及下载，指定pdf文件进行ocr识别，其他pdf文件需求识别文件校验，最后把校验结果放在excel里，如何设计代码逻辑，使效率更快。编写线程安全的代码：在编写并发代码时，需要考虑多线程并发执行可能带来的问题，编写线程安全的代码逻辑，避免出现数据竞争、死锁等问题。
Python线程池 ThreadPoolExecutor 的用法及实战
weixin_30817749的博客
06-06 1296
✨ 前言 从Python3.2开始，标准库为我们提供了 concurrent.futures 模块，它提供了 ThreadPoolExecutor (线程池)和ProcessPoolExecutor (进程池)两个类。 相比 threading 等模块，该模块通过 submit 返回的是一个 future 对象，它是一个未来可期的对象，通过它可以获悉线程的状态主线程(或进程)中可以获取某一个线程(...
【python】ThreadPoolExecutor线程池
种一棵树最好的时间是十年前，其次是现在
10-14 295
在构造函数__init__中，我们传入了两个参数max_workers和max_pending_tasks，分别代表线程池的最大工作线程数和最大挂起任务数。我们还初始化了executor成员变量为一个ThreadPoolExecutor对象，并设置了max_workers为传入的max_workers值，pending_tasks初始化为0。否则，它会使用executor.submit方法来提交任务，并调用_task_wrapper方法包装任务，最后增加挂起任务数并返回任务的Future对象。
「多线程大杀器」Python并发编程利器：ThreadPoolExecutor，让你一次性轻松开启多个线程，秒杀大量任务！
m0_48891301的博客
11-01 776
模块是 Python3.2 中引入的新模块，用于支持异步执行，以及在多核CPU和网络I/O中进行高效的并发编程。这个模块提供了ThreadPoolExecutor和ProcessPoolExecutor两个类，简化了跨平台异步编程的实现。1、多进程当通过多进程来实现并发编程时，程序会将任务分配给多个进程，这些进程可以在不同的CPU上同时运行。进程之间是独立的，各自有自己的内存空间等，可以实现真正的并行执行。
Python3 ThreadPoolExecutor--线程池
weixin_46135872的博客
08-12 2693
Python3 ThreadPoolExecutor
python并发编程基础
最新发布
01-26
Python并发编程是Python编程语言中的一个重要领域，它涉及到如何在单个程序中同时处理多个任务。这通常是通过线程（threads）和进程（processes）实现的，它们允许程序并行执行，从而提高效率和响应速度。在多核...
C语言中文网python并发编程教程
06-16
"Python并发编程详解" Python并发编程是一种高效的编程方式，它可以使程序更加快速、可靠和高效。通过使用多进程和多线程，Python可以同时执行多个任务，提高程序的执行速度和效率。 进程和线程 在Python中，...
Python并发编程专题.zip
01-03
在Python编程中，并发编程是一项核心技能，尤其是在处理大量数据或者需要实时响应用户请求...通过学习这个Python并发编程专题，你将能够熟练掌握各种并发策略，灵活应对不同场景，提升Python程序的执行效率和响应能力。
1.python并发编程.docx
01-10
Python并发编程 Python并发编程是指在Python语言中使用并发编程技术，来提高程序的执行效率和响应速度。 Python并发编程可以使用多种方法来实现，包括多线程、多进程、协程、异步IO等。 在现代计算机系统中，操作...
python3线程池 多线程
qq_27886997的博客
09-27 1315
从Python3.2开始，标准库为我们提供了 concurrent.futures 模块，它提供了 ThreadPoolExecutor (线程池)和ProcessPoolExecutor (进程池)两个类。 相比 threading 等模块，该模块通过 submit 返回的是一个 future 对象，它是一个未来可期的对象，通过它可以获悉线程的状态主线程(或进程)中可以获取某一个线程(进程)执行的状态或者某一个任务执行的状态及返回值： 主线程可以获取某一个线程（或者任务的）的状态，以及返回值。 当一
python多线程
qq_38122800的博客
02-22 106
python多线程
python 中线程池的使用
weixin_43632687的博客
09-24 1308
Python中已经有了threading模块，为什么还需要线程池呢，线程池又是什么东西呢？在介绍线程同步的信号量机制的时候，举得例子是爬虫的例子，需要控制同时爬取的线程数，例子中创建了20个线程，而同时只允许3个线程在运行，但是20个线程都需要创建和销毁，线程的创建是需要消耗系统资源的，有没有更好的方案呢？其实只需要三个线程就行了，每个线程各分配一个任务，剩下的任务排队等待，当某个线程完成了任务的时候，排队任务就可以安排给这个线程继续执行。 这就是线程池的思想（当然没这么简单），但是自己编写线程池很难写的比
python线程池ThreadPoolExecutor的用法
WonderThink的博客
05-31 5115
concurrent.futures模块提供的线程池ThreadPoolExecutor基本用法，获取线程池中任务的运行结果方法。
python线程池模块_Python线程池模块ThreadPoolExecutor用法分析
weixin_39615499的博客
11-28 339
本文实例讲述了Python线程池模块ThreadPoolExecutor用法。分享给大家供大家参考，具体如下：python3内置的有Threadingpool和ThreadPoolExecutor模块，两个都可以做线程池，当然ThreadPoolExecutor会更好用一些，而且也有ProcessPoolExecutor进程池模块，使用方法基本一致。首先导入模块from concurrent.fu...
Python的线程池之ThreadPoolExecutor
张小洛的BOLG
07-25 7243
线程池ThreadPoolExecutor ThreadPoolExecutor位于python3标准库的并发包（concurrent.futures）下，特点 主线程可以获取某一个线程的状态，以及返回值。 线程同步 让多线程和多进程的编码接口一致。 简单粗暴...
python线程池 ThreadPoolExecutor 使用详解
热门推荐
xiaoyu_wu的博客
10-30 4万+
从Python3.2开始，标准库为我们提供了concurrent.futures模块，它提供了 ThreadPoolExecutor 和ProcessPoolExecutor两个类，实现了对threading和multiprocessing 的进一步抽象（这里主要关注线程池），不仅可以自动调度线程，还可以做到： 主线程可以获取某一个线程（或者任务的）的状态，以及返回值。 当一个...
Python 线程池 ThreadPoolExecutor(一) - Python零基础入门教程
07-01 337
目录 一.Python 线程池前言 二.Python 线程池原理 三.Python 线程池 ThreadPoolExecutor 函数介绍 四.Python 线程池 ThreadPoolExecutor 简单使用 五.猜你喜欢 零基础 Python 学习路线推荐 : Python 学习目录 >> Python 基础入门 一.Python 线程池前言 在前面的文章中我们已经介绍了很多关于 Python 线程相关的知识点，比如 线程互斥锁 Lock / 线程事件 Event / 线
python多线程————7、ThreadPoolExecutor线程池
释晓的博客
11-08 2393
所用到的模块：from concurrent.futures import ThreadPoolExecutor,as_completed,wait,FIRST_COMPLETED 1、建立线程池：executor = ThreadPoolExecutor(max_workers= ) 2、提交执行函数到线程池：task = executor.submit(func,(args)) 3、获...
python ThreadPoolExecutor 多线程踩坑之旅
一个CD包的博客
08-10 1万+
背景 最近做了套接口测试系统，后台定时任务会批量去跑测试用例，用的是多线程，以前多线程模块用的是自己封装的包，但因为一些原因近期替换成了python标准库中的ThreadPoolExecutor，于是问题开始了…… 项目用的是：Flask + Flask-SQLAlchemy + Flask-APScheduler 问题描述 定时任务运行时大约有20%的概率会出现问题一与问题二 问题一 py...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

旅程@.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值