[Python笔记12] asyncio并发编程

最新推荐文章于 2024-01-03 15:50:01 发布
最新推荐文章于 2024-01-03 15:50:01 发布
阅读量174 收藏
点赞数
分类专栏： Python高级
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wong_faye/article/details/106105024
版权

1.事件循环

asyncio是python用于解决异步io编程的一整套解决方案
（1）使用asyncio

import asyncio
import time

async def get_html(url):
    print("start get url")
    await asyncio.sleep(2)
    print("end get url")
    
if __name__ == "__main__":
    start_time = time.time()
    loop = asyncio.get_event_loop()
    tasks = [get_html("http://www.baidu.com") for i in range(10)]
    loop.run_until_complete(asyncio.wait(tasks))
    print(time.time() - start_time)

输出结果

start get url
start get url
start get url
start get url
start get url
start get url
start get url
start get url
start get url
start get url
end get url
end get url
end get url
end get url
end get url
end get url
end get url
end get url
end get url
end get url
2.0023303031921387

（2）获取协程的返回值

import asyncio
import time
from functools import partial

async def get_html(url):
    print("start get url")
    await asyncio.sleep(2)
    return "bobby"

def callback(url, future):
    print(url)
    print("send email to bobby")

if __name__ == "__main__":
    start_time = time.time()
    loop = asyncio.get_event_loop()
    task = loop.create_task(get_html("http://www.baidu.com"))
    task.add_done_callback(partial(callback, "http://www.baidu.com"))
    loop.run_until_complete(task)
    print(task.result())

输出结果

start get url
http://www.baidu.com
send email to bobby
bobby

（3）wait 和 gather

import asyncio
import time
async def get_html(url):
    print("start get url")
    await asyncio.sleep(2)
    print("end get url")

if __name__ == "__main__":
    start_time = time.time()
    loop = asyncio.get_event_loop()
    tasks = [get_html("http://www.baidu.com") for i in range(10)]
    loop.run_until_complete(asyncio.gather(*tasks))
    print(time.time()-start_time)

输出结果

start get url
start get url
start get url
start get url
start get url
start get url
start get url
start get url
start get url
start get url
end get url
end get url
end get url
end get url
end get url
end get url
end get url
end get url
end get url
end get url
2.021963357925415

import asyncio
import time
async def get_html(url):
    print("start get url")
    await asyncio.sleep(2)
    print("end get url")

if __name__ == "__main__":
    start_time = time.time()
    loop = asyncio.get_event_loop()
    tasks = [get_html("http://www.baidu.com") for i in range(10)]
    
    group1 = [get_html("http://www.taobao.com") for i in range(2)]
    group2 = [get_html("http://www.jd.com") for i in range(2)]
    group1 = asyncio.gather(*group1)
    group2 = asyncio.gather(*group2)
    loop.run_until_complete(asyncio.gather(group1, group2))
    print(time.time() - start_time)

输出结果

start get url
start get url
start get url
start get url
end get url
end get url
end get url
end get url
2.008810520172119

2.task取消和子协程调用方法

原始代码

import asyncio
import time

async def get_html(sleep_times):
    print("waiting")
    await asyncio.sleep(sleep_times)
    print("done after {}s".format(sleep_times))


if __name__ == "__main__":
    task1 = get_html(2)
    task2 = get_html(3)
    task3 = get_html(3)
    
    tasks = [task1, task2, task3]
    loop = asyncio.get_event_loop()
    loop.run_until_complete(asyncio.wait(tasks))

输出结果

waiting
waiting
waiting
done after 2s
done after 3s
done after 3s

task取消

import asyncio
import time

async def get_html(sleep_times):
    print("waiting")
    await asyncio.sleep(sleep_times)
    print("done after {}s".format(sleep_times))


if __name__ == "__main__":
    task1 = get_html(2)
    task2 = get_html(3)
    task3 = get_html(3)
    
    tasks = [task1, task2, task3]
    loop = asyncio.get_event_loop()
    
    try:
        loop.run_until_complete(asyncio.wait(tasks))
    except KeyboardInterrupt as e:
        all_tasks = asyncio.Task.all_tasks()
        for task in all_tasks:
            print("cancel task")
            print(task.cancel())
        loop.stop()
        loop.run_forever()
    finally:
        loop.close()

运行后按Ctrl+C取消进程，输出结果

waiting
waiting
waiting
cancel task
True
cancel task
True
cancel task
True
cancel task
True

可以看到任务被取消

3.call方法

（1）call_soon

import asyncio

def callback(sleep_times):
    print("success time {}".format(loop.time()))
    
def stoploop(loop):
    loop.stop()

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.call_soon(callback, 2)
    loop.call_soon(stoploop, loop)
    loop.run_forever()

输出结果

success time 34847.328

（2）call_later

import asyncio

def callback(sleep_times):
    print("sleep {} success".format(sleep_times))
    
def stoploop(loop):
    loop.stop()

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.call_later(2, callback, 2)
    loop.call_later(1, callback, 1)
    loop.call_later(3, callback, 3)
    loop.run_forever()

输出结果

sleep 1 success
sleep 2 success
sleep 3 success

call_soon 与 call_later比较

import asyncio

def callback(sleep_times):
    print("sleep {} success".format(sleep_times))
    
def stoploop(loop):
    loop.stop()

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.call_later(2, callback, 2)
    loop.call_later(1, callback, 1)
    loop.call_later(3, callback, 3)
    loop.call_soon(callback, 4)
    loop.run_forever()

输出结果

sleep 4 success
sleep 1 success
sleep 2 success
sleep 3 success

可以看到call_soon 先于 call_later执行
（3）call_at

import asyncio

def callback(sleep_times):
    print("sleep {} success".format(sleep_times))
def stoploop(loop):
    loop.stop()


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    now = loop.time()
    loop.call_at(now+2, callback, 2)
    loop.call_at(now+1, callback, 1)
    loop.call_at(now+3, callback, 3)
    loop.call_soon(callback, 4)
    loop.run_forever()

输出结果

sleep 4 success
sleep 1 success
sleep 2 success
sleep 3 success

实际时间

**import asyncio

def callback(sleep_times, loop):
    print("success time {}".format(loop.time()))
def stoploop(loop):
    loop.stop()

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    now = loop.time()
    loop.call_at(now+2, callback, 2, loop)
    loop.call_at(now+1, callback, 1, loop)
    loop.call_at(now+3, callback, 3, loop)
    loop.call_soon(callback, 4, loop)
    loop.run_forever()**

输出结果

success time 35769.687
success time 35770.687
success time 35771.687
success time 35772.687

4.线程池和asyncio

#使用多线程：在协程中集成阻塞io
import asyncio
from concurrent.futures import ThreadPoolExecutor
import socket
from urllib.parse import urlparse


def get_url(url):
    #通过socket请求html
    url = urlparse(url)
    host = url.netloc
    path = url.path
    if path == "":
        path = "/"

    #建立socket连接
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # client.setblocking(False)
    client.connect((host, 80)) #阻塞不会消耗cpu

    #不停的询问连接是否建立好， 需要while循环不停的去检查状态
    #做计算任务或者再次发起其他的连接请求

    client.send("GET {} HTTP/1.1\r\nHost:{}\r\nConnection:close\r\n\r\n".format(path, host).encode("utf8"))

    data = b""
    while True:
        d = client.recv(1024)
        if d:
            data += d
        else:
            break

    data = data.decode("utf8")
    html_data = data.split("\r\n\r\n")[1]
    print(html_data)
    client.close()


if __name__ == "__main__":
    import time
    start_time = time.time()
    loop = asyncio.get_event_loop()
    executor = ThreadPoolExecutor(3)
    tasks = []
    for url in range(20):
        url = "http://shop.projectsedu.com/goods/{}/".format(url)
        task = loop.run_in_executor(executor, get_url, url)
        tasks.append(task)
    loop.run_until_complete(asyncio.wait(tasks))
    print("last time:{}".format(time.time()-start_time))

输出结果

{"detail":"未找到。"}
{"id":1,"category":{"id":129,"sub_cat":[],"name":"根茎类","code":"gjl","desc":"","category_type":2,"is_tab":false,"add_time":"2017-07-29T18:56:34","parent_category":110},"images":[{"image":"http://shop.projectsedu.com/media/goods/images/1_P_1449024889889.jpg"},{"image":"http://shop.projectsedu.com/media/goods/images/1_P_1449024889264.jpg"},{"image":"http://shop.projectsedu.com/media/goods/images/1_P_1449024889726.jpg"},{"image":"http://shop.projectsedu.com/media/goods/images/1_P_1449024889018.jpg"},{"image":"http://shop.projectsedu.com/media/goods/images/1_P_1449024889287.jpg"}],"goods_sn":"","name":"新鲜水果甜蜜香脆单果约800克","click_num":6435,"sold_num":0,"fav_num":1,"goods_num":-17,"market_price":232.0,"shop_price":156.0,"goods_brief":"食
.....
.....
.....
ages/2_20170719161435_381.jpg\" title=\"\" alt=\"2.jpg\"/></p>","ship_free":true,"goods_front_image":"http://shop.projectsedu.com/media/goods/images/21_P_1448946793276.jpg","is_new":false,"is_hot":false,"add_time":"2017-07-31T23:53:54"}

last time:1.271043300628662

5.asyncio模拟http请求

#asyncio 没有提供http协议的接口 aiohttp
import asyncio
import socket
from urllib.parse import urlparse


async def get_url(url):
    #通过socket请求html
    url = urlparse(url)
    host = url.netloc
    path = url.path
    if path == "":
        path = "/"

    #建立socket连接
    reader, writer = await asyncio.open_connection(host,80)
    writer.write("GET {} HTTP/1.1\r\nHost:{}\r\nConnection:close\r\n\r\n".format(path, host).encode("utf8"))
    all_lines = []
    async for raw_line in reader:
        data = raw_line.decode("utf8")
        all_lines.append(data)
    html = "\n".join(all_lines)
    return html

async def main():
    tasks = []
    for url in range(20):
        url = "http://shop.projectsedu.com/goods/{}/".format(url)
        tasks.append(asyncio.ensure_future(get_url(url)))
    for task in asyncio.as_completed(tasks):
        result = await task
        print(result)

if __name__ == "__main__":
    import time
    start_time = time.time()
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())
    print('last time:{}'.format(time.time()-start_time))

输出结果

HTTP/1.1 404 Not Found
Server: nginx/1.16.1
Date: Wed, 20 May 2020 09:59:48 GMT
Content-Type: application/json
Content-Length: 25
Connection: close
Vary: Accept, Cookie
Allow: GET, HEAD, OPTIONS
X-Frame-Options: SAMEORIGIN


{"detail":"未找到。"}
HTTP/1.1 200 OK
Server: nginx/1.16.1
Date: Wed, 20 May 2020 09:59:48 GMT
Content-Type: application/json
Content-Length: 980
Connection: close
Vary: Accept, Cookie
Allow: GET, HEAD, OPTIONS
X-Frame-Options: SAMEORIGIN


{"id":6,"category":{"id":130,"sub_cat":[],"name":"茄果类","code":"qgl","desc":"","category_type":2,"is_tab":false,"add_time":"2017-07-29T18:56:34","parent_category":110},"images":[{"image":"http://shop.projectsedu.com/media/goods/images/4_P_1448945381985.jpg"},{"image":"http://shop.projectsedu.com/media/goods/images/4_P_1448945381013.jpg"}],"goods_sn":"","name":"乌拉圭进口牛肉卷特级肥牛卷","click_num":3700,"sold_num":0,"fav_num":0,"goods_num":0,"market_price":90.0,"shop_price":75.0,"goods_brief":"","goods_desc":"<p><img src=\"/media/goods/images/2_20170719161405_249.jpg\" title=\"\" alt=\"2.jpg\"/></p><p><img src=\"/media/goods/images/2_20170719161414_628.jpg\" title=\"\" alt=\"2.jpg\"/></p><p><img src=\"/media/goods/images/2_20170719161435_381.jpg\" title=\"\" alt=\"2.jpg\"/></p>","ship_free":true,"goods_front_image":"http://shop.projectsedu.com/media/goods/images/4_P_1448945381985.jpg","is_new":false,"is_hot":false,"add_time":"2017-07-31T23:53:53"}

....
....
....
last time:0.8495240211486816
wong_faye
关注
专栏目录
Python入门：asyncio异步编程结果处理
XiaoqiangClub的博客
09-30 125
Python入门：asyncio异步编程结果处理
Python：asyncio.wait 和 asyncio.gather 总结
weixin_36273267的博客
05-29 4268
Futurefuture是一个数据结构，表示还未完成的工作结果。事件循环可以监视Future对象是否完成。从而允许应用的一部分等待另一部分完成一些工作。Future获取Futrue里的结果future表示还没有完成的工作结果。事件循环可以通过监视一个future对象的状态来指示它已经完成。future对象有几个状态：PendingRunningDoneCancelled。
利用asyncio并发下载pdf并同步到七牛云网盘
qq_15058425的博客
04-19 485
#pdf下载并上传到七牛云 # -*- coding: utf-8 -*- import aiohttp import asyncio import redis import re import time import os import pymysql from qiniu import Auth from qiniu import put_file import logging lo...
python asyncio_python异步编程之asyncio（百万并发）
weixin_39551611的博客
11-20 315
前言：python由于GIL（全局锁）的存在，不能发挥多核的优势，其性能一直饱受诟病。然而在IO密集型的网络编程里，异步处理比同步处理能提升成百上千倍的效率，弥补了python性能方面的短板，如最新的微服务框架japronto，resquests per second可达百万级。python还有一个优势是库（第三方库）极为丰富，运用十分方便。asyncio是python3.4版本引入到标准库，py...
asyncio并发数_asyncio并发编程
weixin_36078604的博客
01-26 291
ThreadPoolExecutor和asyncio完成阻塞IO请求这个小节我们看下如何将线程池和asyncio结合起来。在协程里面我们还是需要使用多线程的，那什么时候需要使用多线程呢？我们知道协程里面是不能加入阻塞IO的，但是有时我们必须执行阻塞IO的操作的时候，我们就需要多线程编程了，即我们要在协程中集成阻塞IO的时候就需要多线程操作。12345678910111213141516171819...
深入异步IO框架：asyncio 中篇
王炳明
10-26 654
今天的内容其实还挺多的，我准备了三天，到今天才整理完毕。希望大家看完，有所收获的，能给小明一个赞。这就是对小明最大的鼓励了。 为了更好地衔接这一节，我们先来回顾一下上一节的内容。 上一节，我们首先介绍了，如何创建一个协程对象. 主要有两种方法 通过async关键字， 通过@asyncio.coroutine 装饰函数。 然后有了协程对象，就需要一个事件循环容器来运行我们的协程。其主要的步骤有如下几点： 将协程对象转为task任务对象 定义一个事件循环对象容器用来存放task 将task任务扔进事件循环
Python Asyncio 并发编程
weixin_yuanweiyaonie的博客
04-01 611
使用多线程和普通的单线程相比，其运行效率会有极大的提高。但不得不说，多线程虽然有诸多优势，也存在一定的局限性： 多线程运行过程中容易被打断，还可能出现多个线程同时竞争同一资源的情况； 多线程切换本身存在一定的损耗，线程数不能无线增加，因此如果I\O操作非常频繁，多线程很有可能满足不了高效率、高质量的需求。 为了解决这些问题，Asyncio 并发编程应运而生。 在详细介绍 Asyncio 之前，要先搞清楚什么是同步，什么是异步。所谓同步，是指操作一个接一个地执行，下一个操作必须等上一个操作执行完成之后才能开
学习笔记(13):Python网络编程&并发编程-解决粘包问题-终极版本
12-22
并发编程在Python中可以通过多线程、多进程或异步IO等方式实现。在这个场景下，如果同时有多个客户端请求，可以考虑使用线程池或者异步IO模型（如`asyncio`库）来处理并发连接，提高服务器的响应效率。 总结来说，...
Python非常详细编程笔记.zip_python 详细笔记_python编程
09-19
13. **并发编程**：Python的线程和进程，以及异步I/O模型（如asyncio库）。 14. **数据分析和科学计算**：可能会提到NumPy、Pandas和Matplotlib等库，它们在数据分析和可视化中的应用。 15. **Web开发**：基础的...
Python Asyncio 之网络编程方法详解
weixin_68789096的博客
08-31 911
提供了一套完整的高性能网络编程接口，它包括了兼容位于网络编程最底层的Socket，以及在上层封装的ProtocolTransport接口，还有在ProtocolTransport上层封装的Stream接口。这三套接口各有特色，开发者可以根据自己的需求选择其中一套接口来使用，进而减少网络编程的一些心理负担。三套接口的关系就跟套娃一样，Stream套在ProtocolTransport上面 ，而ProtocolTransport套在Socket上面，由于Stream。
【python高级】asyncio 并发编程
爱干饭的猿的博客
11-10 329
本文重点介绍python高级篇的事件循环，task取消和协程嵌套、call_soon、call_later、call_at、 call_soon_threadsafe、asyncio模拟http请求、asyncio同步和通信、aiohttp实现高并发实践。
Python有关于asyncio内置库并发编程教程，协程并发的实现（更新中）
唤醒手腕
06-11 797
所谓「异步 IO」，就是你发起一个 IO 操作，却不用等它结束，你可以继续做其他事情，当它结束时，你会得到通知。 Asyncio 是并发（concurrency）的一种方式。当然对 Python 来说，并发编程还可以通过线程（threading）和多进程（multiprocessing）来实现。Asyncio 并不能带来真正的并行（parallelism）。 当然，因为 GIL（全局解释器锁）的存在，Python 的多线程也不能带来真正的并行。 可交给 asyncio 执行的任务，称为协程（corout
python 高性能编程 异步并发编程 asyncio 协程笔记暂记
ResumeProject的博客
06-03 561
异步并发编程-相关概念 同步：按照顺序执行：js同步的实现 异步：非同步。一起执行，但是异步不一定就是多线程，比如JavaScript 的运行时是跑在单线程上的，所有同步任务都在主线程上执行，形成一个执行栈（execution context stack）。主线程之外，还存在一个”任务队列”（task queue）。只要异步任务有了运行结果，就在”任务队列”之中放置一个事件。一旦”执行栈”中的所有同步任务执行完毕，系统就会读取”任务队列”，看看里面有哪些事件。那些对应的异步任务，于是结束等待状态，进入执行
Python编程：使用asyncio包处理并发
weixin_56051592的博客
01-06 465
Python经典进阶教程！
Python中的并发编程：asyncio库入门
小小张说故事的博客
05-18 511
Python的asyncio库为我们提供了强大的异步编程功能，使我们能够编写更高效的并发程序。我们已经介绍了如何使用asyncio创建简单的异步程序、运行多个协程、创建TCP服务器以及调度协程和任务等。通过学习和实践这些功能，你将能够更好地利用Python的并发编程能力，提高你的程序性能。
Python进阶:Asyncio并发编程
最新发布
nzbing的博客
01-03 1304
和其它Python程序一样,是单线程的,只有一个主线程,但是可以进行多个不同的任务(task),这里的任务,就是特殊的future对象,这些不同的任务,被一个叫做event loop的对象所控制。可以把这里的任务,类比多线程版本里的多个线程上述代码是爬虫的简单示例,四个url一共用了10s的时间,如何用协程进行优化呢?async:声明异步函数,上面的crawl_page和main都成了异步函数await:协程的关键字,后面接异步函数1、当遇到 await 关键字时，协程会暂停自己的执行。
python并发2：使用asyncio处理并发
weixin_34232617的博客
06-23 392
asyncio asyncio 是Python3.4 之后引入的标准库的，这个包使用事件循环驱动的协程实现并发。asyncio 包在引入标准库之前代号 “Tulip”（郁金香），所以在网上搜索资料时，会经常看到这种花的名字。 什么是事件循环? wiki 上说：事件循环是”一种等待程序分配事件或者消息的编程架构“。基本上来说事件循环就是：”...
python并发编程：协程asyncio、多线程threading、多进程multiprocessing
Xzike的博客
03-17 6143
python中的asyncioTask对象 Task对象 tasks用于并发调度协程，通过asyncio.creat_task(协程对象)的方式可以创建Task对象，这样可以让协程加入事件循环中等待被调度执行。除了使用asyncio.creat_task()以外，还可以用低层级的loop.creat_task()或asyncio.ensure_future()。 注意：asyncio.creat_task()在python3.7之后加入。在python3.7之前可以改用低层级的asyncio.ensure_
python：并发编程（十）
weixin_43431593的博客
06-16 791
本文将和大家一起探讨python的多协程并发编程（上篇），使用内置基本库asyncio来实现并发，先通过官方来简单使用这个模块。先打好基础，能够有个基本的用法与认知，后续文章，我们再进行详细使用。
Python asyncio并发编程详解与实战应用
asyncio是一个专门为Python设计的事件驱动并发框架，它的引入旨在解决传统网络编程库如Twisted、Tornado和Gevent之间的不兼容性，提供了一种基于生成器的原生异步IO支持。 事件循环是asyncio的核心概念，它类似于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值