Python中的多进程、多线程、协程

已于 2024-05-13 20:07:47 修改
阅读量942 收藏 21
点赞数 28
分类专栏： Python语言 python高级用法 文章标签： python 线程 进程 协程
于 2024-05-10 19:53:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73910510/article/details/138679227
版权

Python中的多线程、多进程、协程

一、概述

1. 多线程Thread （threading）：

  • 优点：同一个进程中可以启动多个线程，充分利用IO时，cpu进行等待的时间
  • 缺点：相对于进程，多线程只能并发执行，不能利用多CPU，相对于协程，多线程的启动数目有限 ，占用内存资源，并且有线程切换的时间开销
  • 使用场景：IO密集型计算、同时运行的任务数据要求不多

2. 多进程Process（multiprocessing）:

  • 优点：可以利用多核CPU进行并行计算
  • 缺点：占用资源最多，可启动的数目比线程少
  • 使用场景：CPU密集型计算

3. 协程Coroutine（asyncio）:

  • 优点：内存开销最少、启动协程的数量最多
  • 缺点：支持的库有限制 (request对用的能使用协程的库为：aiohttp)、代码实现复杂
  • 使用场景：IO密集型计算、超多任务运行、有现成的库支持的场景

4. Python比C/C++/Java速度慢的原因：

  1. Python是动态类型语言，边解释边执行。
  2. GIL，无法利用多核CPU并发 执行。

5. GIL

GIL名为：全局解释器锁（Global Interpreter Lock 缩写为： GIL），是计算机程序设计语言解释器用于同步线程的一种机制，它使得任何时刻仅有一个线程在执行，即便在多核心处理器上，使用GIL的解释器也只允许同一时刻执行一个线程。这是为了解决多线程之间数据完整性的状态同步问题。

6. 创建工具代码：

这个代码是一个基本的爬虫代码，创建这个代码的目的时为了下面实现多线程或多进程的时候让代码显的更加简洁，进而能更清晰的观察到多线程或多进程的实现方式。

utils.blog_spider.py

import requests
from bs4 import BeautifulSoup

urls = [
    f'https://www.cnblogs.com/#p{page}'
    for page in range(1, 50 + 1)
]

# 请求url，得到html
def craw(url):
    r = requests.get(url)
    # print(url, len(r.text))
    return r.text

# 解析html
def parse(html):
    soup = BeautifulSoup(html, "html.parser")
    links = soup.find_all("a", class_="post-item-title")
    return [(link['href'], link.get_text()) for link in links]


if __name__ == '__main__':
    for restult in parse(craw(urls[2])):
        print(restult)

二、多线程

1. 创建多线程的一般流程：

  1. 准备一个函数

    def my_func(a, b):
	doing(a, b)

  2. 创建一个线程

    import threading  # 导入线程包
t = threading.Threading(target=my_func, args=(100, 200))  # 第一个参数为一个函数名，第二个参数时传入函数的参数

  3. 启动线程

    t.start()

  4. 等待结束

    t.join()

代码示例：

# 多线程爬虫
import threading
import time

import utils.blog_spider as bg


def signal_thread():
    for url in bg.urls:
        bg.craw(url)


def multi_thread():
    threads = []
    for url in bg.urls:
        threads.append(threading.Thread(target=bg.craw, args=(url,)))  # 添加线程
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join()


if __name__ == '__main__':
    start = time.time()
    signal_thread()
    end = time.time()
    print("signal_thread cosst :", end - start, "seconds")

    start = time.time()
    multi_thread()
    end = time.time()
    print("multi_thread cosst :", end - start, "seconds")

输出结果：

在这里插入图片描述

在这里插入图片描述

2. 多线程之间的数据通信queue.Queue

queue.Queue可以用于多线程之间、线程安全的数据通信。

具体流程如下 ：

  1. 导入队列库

    import queue

  2. 创建Queue

    q = queue.Queue()

  3. 添加元素

    q.put(item)

  4. 获取元素

    item = q.get()

  5. 查询状态

    # 查看元素的多少
q.qsize()
               
# 判断是否为空
q.empty()
               
# 判断是否已满
q.full()

代码示例：

# 多线程数据通信
import queue
import utils.blog_spider as bg
import time
import random
import threading


def do_craw(url_queue: queue.Queue, html_queue: queue.Queue):
    while True:
        url = url_queue.get()
        html = bg.craw(url)
        html_queue.put(html)   # 加入队列
        print(threading.current_thread().name, f"craw{url}", "url_queue.size=", url_queue.qsize())
        time.sleep(random.randint(1, 2))  # 进行随机休眠


def do_parse(html_queue: queue.Queue, fout):
    while True:
        html = html_queue.get()  # 从队列中取数据
        results = bg.parse(html)
        for result in results:
            fout.write(str(result) + '\n')
        print(threading.current_thread().name, "results.size=", len(results), "html_queue.size=", html_queue.qsize())
        time.sleep(random.randint(1, 2))


if __name__ == '__main__':
    url_queue = queue.Queue()
    html_queue = queue.Queue()
    for url in bg.urls:
        url_queue.put(url)
    for idx in range(3):
        t = threading.Thread(target=do_craw, args=(url_queue, html_queue), name=f"craw{idx}")
        t.start()
    fout = open("data.txt", "w")
    for idx in range(2):
        t = threading.Thread(target=do_parse, args=(html_queue, fout), name=f"parse{idx}")
        t.start()

在这里插入图片描述

3. 线程安全

由于线程的执行随时会切换，这会造成不可预料的结果，出现线程不安全的情况。

Lock用于解决线程安全问题，对线程进行加锁，这样会使得该线程运行结束之后在切换线程。

用法1：try-finally模式

import threading
lock = threading.Lock()   # 设置线程锁
lock.acquire()  # 获得锁
try:
    # do something
finally:
    lock.realse()   # 释放锁

用法2：with模式

import threading
lock = threading.Lock()
with lock:
    # do something

sleep语句一定会导致当前线程阻塞，会进行线程的切换（加锁则不会进行进程的切换）。

代码示例：

# 线程安全
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)
            print(threading.current_thread().name, "取钱成功")
            account.balance -= amount
            print(threading.current_thread().name, "余额", account.balance)
        else:
            print(threading.current_thread().name, "取钱失败，余额不足")


if __name__ == '__main__':
    account = Account(1000)
    ta = threading.Thread(name="ta", target=draw, args=(account, 800))
    tb = threading.Thread(name='tb', target=draw, args=(account, 800))

    ta.start()
    tb.start()

在这里插入图片描述

4. 线程池

线程池中有一些线程，新来的任务放在任务队列中，在线程池中的线程空闲的时候会自动处理任务队列里的任务。

使用线程池的好处：

  1. 提升性能
    因为减去了大量新建、终止线程的开销，重用了线程资源；
  2. 使用场景
    适合处理突发性大量请求或需要大量线程完成任务，但实际任务处理时间较短。
  3. 防御功能
    能有效避免系统因为创建线程过多，而导致系统负荷过大相应变慢的问题。
  4. 代码优势
    使用线程池的语法比自己新建线程执行线程更加简洁。

使用方法：

  1. 用法1：map函数，注意map的结果和入参是顺序对应的。

    from concurrent.futures import ThreadPoolExecutor, as_completed
with ThreadPoolExecutor() as pool:
    results = pool.map(craw, urls)
    for result in results:
        print(result)

  2. 用法2：future模式更强大，注意如果用as_complete方法，这样的线程执行顺序是不固定的，但是相应的效率会更高。（as_completed方法是不管哪个线程先执行完了，都会直接返回，不用按照顺序返回）

    with ThreadPoolExecutor() as pool:
    futures = [pool.submit(craw, url) for url in urls]
    for future in futures:
        print(future.result())
    for future in as_complated(futures):
        print(future.result())

代码示例：

import concurrent.futures
import utils.blog_spider as bg

# 进行爬取html
with concurrent.futures.ThreadPoolExecutor() as pool:
    htmls = pool.map(bg.craw, bg.urls)  # 加入线程池
    htmls = list(zip(bg.urls, htmls))
    for url, html in htmls:
        print(url, len(html))
    print("craw over")

# 进行解析html
with concurrent.futures.ThreadPoolExecutor() as pool:
    futures = {}
    for url, html in htmls:
        future = pool.submit(bg.parse, html)  # 加入线程池
        futures[future] = url
    for future, url in futures.items():
        print(url, future.result())

    # 顺序不定
    # for future in concurrent.futures.as_completed(futures):
    #     url = futures[future]
    #     print(url, future.result())

三、多进程

CPU密集型计算线程的自动的切换反而变成了负担，多线程甚至减慢了运行速度。multiprocessing模块就是Python为了解决GIL缺陷引入的一个模块，原理是用多进程在多CPU上并行执行。

多进程multiprocessing知识梳理（对比多线程threading）

多线程：

  1. 引入模块

    from threading import Thread

  2. 新建

    t = Thread(target=func, args=(100, ))

  3. 启动

    t.start()

  4. 等待结束

    t.join()

  5. 数据通信

    import queue
q = queue.Queue()
q.put(item)
item = q.get()

  6. 线程安全加锁

    from threading import Lock
lock = Lock()
with lock:
    # do something

  7. 池化技术

    from concurrent.futures import ThreadPoolExecutor
with ThreadPoolExecutor() as executor:
    # 方法1
    results = executor.map(func, [1, 2, 3])
    # 方法2
    future = executor.submit(func, 1)
    result = future.result()

多进程：

  1. 引入模块：

    from multiprocessing import Process

  2. 新建

    p = process(target=f, args=('bob', ))

  3. 启动

    p.start()

  4. 等待结束

    p.join()

  5. 数据通信

    from multiprocessing import Queue
q = Queue()
q.put([42, None, 'hello'])
item = q.get()

  6. 线程安全加锁

    from  multiprocessing import Lock
lock = Lock()
with lock:
    # do something

  7. 池化技术

    from concurrent.futures import ProcessPoolExecutor
with ProcessPoolExecutor() as executor:
    # 方法1：
    results = executor.map(func, [1, 2, 3])
    # 方法2：
    future = executor.submit(func, 1)
    result = funture.result()

代码示例：

import math
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor  # 导入线程池与进程池
import time

PRIMES = [112272535095293] * 100


def is_prime(n):
    '''
    判断一个数是否是素数
    :param n:
    :return:
    '''
    if n < 2:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    sqrt_n = int(math.floor(math.sqrt(n)))
    for i in range(3, sqrt_n + 1, 2):
        if n % i == 0:
            return False
    return True


def signal_thread():
    '''
    单线程
    :return:
    '''
    for number in PRIMES:
        is_prime(number)


def multi_thread():
    '''
    多线程
    :return:
    '''
    with ThreadPoolExecutor() as pool:
        pool.map(is_prime, PRIMES)


def multi_process():
    '''
    多进程
    :return:
    '''
    with ProcessPoolExecutor() as pool:
        pool.map(is_prime, PRIMES)


if __name__ == '__main__':
    start = time.time()
    signal_thread()
    end = time.time()
    print("signal_thread, cost:", end - start, "seconds")

    start = time.time()
    multi_thread()
    end = time.time()
    print("multi_thread, cost:", end - start, "seconds")


    start = time.time()
    multi_process()
    end = time.time()
    print("multi_process, cost:", end - start, "seconds")

输出结果：

在这里插入图片描述

四、协程

协程是在单线程内实现并发

  • 核心原理：用一个超级循环（其实就是while Treu）循环
  • 配合IO多路复用原理（IO时CPU可以干其他事情）

异步IO库介绍：asyncio

1. 创建协程的一般流程：

  1. 导入库

    import asyncio

  2. 获取事件循环

    loop = asyncio.get_enent_loop()

  3. 定义协程

    async def myfunc(url):
    await get_url(url)

  4. 创建task任务列表

    task = [loop.create_task(myfunc(url)) for url in urls]

  5. 执行爬虫事件列表

    loop.run_until_complete(asyncio.wait(tasks))

注意：要用在异步IO编程中，依赖的库必须支持异步IO特性，爬虫引用中：requests不支持异步，需要用aiohttp

代码示例：

import asyncio
import aiohttp
import utils.blog_spider as bg   # 该模块是工具代码中的模块
import time


async def async_craw(url):
    print("craw url:", url)
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            result = await resp.text()
            print(f"craw url: {url}, {len(result)}")


loop = asyncio.get_event_loop()
tasks = [loop.create_task(async_craw(url=url))   # 添加任务
         for url in bg.urls]

start = time.time()
loop.run_until_complete(asyncio.wait(tasks))   # 启动协程
end = time.time()
print("use time seconds :", end - start)

在这里插入图片描述

2. 控制协程的并发度

可以使用信号量(semaphore)来控制并发度

实现方式1：

sem = asyncio.Semaphore(10)
# later
async with sem:
    # work with shared resource

实现方式2：

sem = asyncio.Semaphore(10)
# later
await sem.acquire()
try:
    # work with shared resource
finally:
    sem.release()
_Soy_Milk
关注
  • 28
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入浅析python中的多进程、多线程、协程
09-21
主要介绍了深入浅析python中的多进程、多线程、协程 的相关资料,非常不错，具有参考借鉴价值，需要的朋友可以参考下
多协程、多线程、多进程代码
01-08
在Python编程中，多协程、多线程和多进程是实现并发执行任务的重要机制，它们可以帮助我们提高程序的执行效率，充分利用系统资源。本文将深入探讨这些概念以及它们在Python中的实现方式。 首先，我们要了解并发的...
python中的进程线程和协程
ximu__l的博客
04-30 1129
介绍了进程、线程和协程，并通过实例对三种操作进行了展示，最后说明了适合三种并发操作方式的相应场景和任务。
Python实现多进程、多线程以及多协程任务
qq_51350363的博客
06-19 2757
第三步：进程对象使用multiprocessing.Process();第四步：进程对象.start()正式创建进程。1.4 通过Quene实现多进程之间的通信。3.2 使用gevent实现协程多任务。3.1 使用gevent实现协程。第五步：主进程继续向下运行代码。1.1 多进程函数实现多任务。二、 python实现多线程。2.2 多线程函数实现多任务。三、 python实现多协程。一、python实现多进程。1.2 多进程类实现多任务。2.1 创建对象并传递参数。2.3 多线程类实现多任务。
Python（黄金时代）——多线程、多进程、协程
qq_25702235的博客
03-30 1142
在g_num=0 时，t1取得g_num=0，此时系统把t1调度为 "sleeping" 状态，把t2转换为 "running" 状态，t2 这时也获得了 g_num=0。它被包涵在进程之中，是进程中的实际运作单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。同一个进程的多个线程，共用地址空间，多线程相比于多进程，稳定性要差，因为一个线程出现问题会严重影响其他线程。然后 t2对得到的值进行加1，并赋给g_num，使得g_num=1。
python多线程多进程和协程总结
csdncjh的博客
10-15 3819
真正意义上的多线程是由CPU来控制的，例如如果一个CPU密集型的程序，用C语言写，运行在一个四核处理器上，采用多线程的话最多可以获得4倍的效率提升。但是用Python写的话，效率不会提高，甚至会变慢，因为Python中的多线程是由GIL控制的，GIL的全称是Global Interpreter Lock（全局解释器锁），Python最初的设计理念在于，为了解决多线程之间数据完整性和状态同步的问题，设计为在任意时刻只能由一个线程在解释器中运行。
Python 多进程&多线程&线程池&进程池&协程
喵酱
02-26 3150
Python 多进程&多线程&线程池&进程池&协程
[Python系列] 线程、协程、进程和分布式
u013379032的博客
07-11 1580
在了解什么是多线程之前，我们需要先了解线程。线程，是程序执行时的最小单位，是CPU调度和分配的基本单位。多线程是指在单个程序中同时执行多个任务的过程，每个任务被称为一个线程。在一个多线程程序中，每个线程都可以独立地运行，直到它们被中断或手动停止。多线程的好处是，它能够充分利用多核处理器的优势，提高程序的执行效率。同时，多线程也能够使程序更加灵活，可以根据不同的任务需求来分配不同的线程，从而更好地满足用户的需求。
python 多进程和协程配合使用写入数据
12-16
在Python编程中，多进程和协程是两种不同的并发处理方式，它们各有优势，并且可以协同工作以提高程序效率。本示例展示了如何在处理大量数据时，利用多进程读取文件并用协程进行数据处理，从而实现高效的数据处理流程...
python爬虫之多线程、多进程爬虫
02-24
多线程对爬虫的效率提高是非凡的，当我们使用python的多线程有几点是需要我们知道的：1.Python的多线程并不如java的多线程，其差异在于当python解释器开始执行任务时，受制于GIL(全局解释所)，Python的线程被限制到...
python线程、进程和协程详解
09-21
然而，由于GIL（全局解释器锁）的存在，Python的多线程在CPU密集型任务上并不能实现真正意义上的并行，但在IO密集型任务中，可以通过线程交替执行，提高程序效率。例如创建线程： ```python import threading def ...
深入理解python的多线程，多进程和协程（多线程）
努力下来就凸头
04-20 2291
python的并发编程多线程，多进程和协程深入理解
python 多线程和协程的区别
ch_atu的博客
09-23 1388
都能进行多任务。
2024年最新Python--多任务（多进程，多线程，协程）_python多进程任务
最新发布
2401_84557926的博客
05-02 55
”“完成文件的复制”“”# print(“=====>模拟copy文件：从%s---->到%s 文件名：%s” % (old_folder_name,new_folder_name,file_name))# 1.获取用户要copy的文件夹的名字old_folder_name = input(“请输入要copy的文件夹的名字：”)ifmain()
Python中的多线程与协程的比较与应用场景
weixin_71166183的博客
01-02 1236
Python中的多线程和协程提供了不同的并发编程模型，它们各有优缺点，并且适用于不同的场景。在实际应用中，可以根据任务的特点和需求来选择合适的并发模型，甚至可以将它们结合起来使用以充分发挥各自的优势。对于一些既包含CPU密集型任务又包含IO密集型任务的复杂应用，可以考虑使用多线程来处理CPU密集型任务，同时使用协程来处理IO密集型任务。多线程可以利用多核CPU的并行计算能力，但由于Python的全局解释器锁（GIL）的存在，多线程在CPU密集型任务上并不能实现真正的并行计算，而更适合于IO密集型任务。
Python中的协程、线程和进程
NLP工程化
01-02 1507
协程、多线程和多进程都是实现程序并发执行的方法，不过它们在工作方式和适合的应用场景上存在一些区别。
python3--进程,线程,协程效率对比
qq_43966957的博客
11-25 443
python3--进程,线程,协程效率对比
Python的多进程 多线程 协程的区别
03-07
Python的多进程、多线程和协程都是实现并发编程的方式，但它们的实现方式和应用场景有所不同。 多进程是指在一个程序中同时运行多个进程，每个进程都有自己的独立内存空间和系统资源，它们之间通过进程间通信来交换数据。多进程适用于CPU密集型任务，可以利用多核CPU提高程序的执行效率。 多线程是指在一个进程中同时运行多个线程，每个线程共享进程的内存空间和系统资源，它们之间通过共享内存来交换数据。多线程适用于IO密集型任务，可以在等待IO操作的同时执行其他任务，提高程序的响应速度。 协程是一种轻量级的线程，它在一个线程中实现多个协程的切换，每个协程都有自己的执行流程和状态，可以通过yield语句来实现协程的切换。协程适用于IO密集型任务，可以在等待IO操作的同时执行其他任务，提高程序的响应速度。 总之，多进程适用于CPU密集型任务，多线程和协程适用于IO密集型任务，选择合适的并发编程方式可以提高程序的执行效率和响应速度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值