Python协程与异步编程——asyncio
协程
协程(Coroutine)，也可以被称为微线程，是一种用户态内的上下文切换技术。简而言之，其实就是通过一个线程实现代码块相互切换执行。也是说协程不是操作系统提供的，是程序员人为创造的。例如:
def func1():
print(1)
print(2)
def func2():
print(3)
print(4)
func1()
func2()
实现协程有这么几种方法:
- greenlet，早期模块。
- yield关键字。
- asyncio装饰器(py3.4)
- async、await关键字(py3.5)【推荐】
greenlet实现协程
这就是由greenlet做的：由一个线程在执行代码的时候，在多个函数之间进行来回切换执行。
from greenlet import greenlet
def func1():
print(1)
gr2.switch()
print(2)
gr2.switch()
def func2():
print(3)
gr1.switch()
print(4)
gr1 = greenlet(func1)
gr2 = greenlet(func2)
gr1.switch()
输出：
1
3
2
4
yield关键字
注意：了解他也能实现这个协程功能，但我们一般不用此方法。
def func1():
yield 1
yield from func2()
yield 2
def func2():
yield 3
yield 4
f1 = func1()
for item in f1:
print(item)
输出：
1
3
4
2
asyncio
注意：python的版本要＞=3.4，才有这个功能。
这里简单了解asyncio，下文详细讲内部函数与使用。
在python3.8之前的版本：
import asyncio
# @asyncio.coroutine的作用是将普通函数变为写成函数
@asyncio.coroutine
def func1():
print(1)
yield from asyncio.sleep(2) # 遇到IO耗时操作, 自动化切换到tasks中的其他任务
print(2)
@asyncio.coroutine
def func2():
print(3)
yield from asyncio.sleep(2) # 遇到IO耗时操作, 自动化切换到tasks中的其他任务
print(4)
tasks = [
asyncio.ensure_future(func1()),
asyncio.ensure_future(func2())
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
输出：
1
3
然后等sleep(2)，也就是两秒后再打印
2
4
在Python3.8之后的版本：@asyncio.coroutine 装饰器和 yield from 语法已被弃用，用的是asynic 和 await
asynic 和 await
import asyncio
import nest_asyncio
# 使用 async 定义异步函数
async def func1():
print(1)
# 使用 await 等待异步操作完成
await asyncio.sleep(2)
print(2)
async def func2():
print(3)
await asyncio.sleep(2)
print(4)
async def main():
# 创建任务列表
tasks = [
asyncio.create_task(func1()),
asyncio.create_task(func2())
]
# 等待所有任务完成
await asyncio.gather(*tasks)
# 应用nest_asyncio补丁（在 Jupyter Notebook 中，可以使用 nest_asyncio 库来解决嵌套事件循环的问题。若不是此环境则不需呀下一行）
nest_asyncio.apply()
if __name__ == "__main__":
# 运行异步函数
asyncio.run(main())
输出：
1
3
然后等sleep(2)，也就是两秒后再打印
2
4
他的有点好在，遇到IO耗时操作（或叫IO阻塞）, 自动化切换到tasks中的其他任务！
意义
在一个线程中如果遇到IO等待时间，线程不会傻等，利用空闲的时候再去干点其他事。
例子：去下载三张图片(网络IO)
- 普通方式（同步操作）
此方法就是先下载完第一张图片再下第二张再第三张，一步步下，比如一张为1s，那么我们执行就需要3s。
""" pip3 install requests """
import requests
def download_image(url):
print("开始下载:", url)
# 发送网络请求，下载图片
response = requests.get(url)
print("下载完成")
# 图片保存到本地文件
file_name = url.rsplit('/', 1)[-1]
with open(file_name, mode='wb') as file_object:
file_object.write(response.content)
if __name__ == '__main__':
url_list = [
'https://th.bing.com/th/id/OIP.7TR2k4QU06TiowN6oiuZAAHaGk?w=195&h=180&c=7&r=0&o=5&dpr=1.1&pid=1.7.jpg',
'https://th.bing.com/th/id/OIP.Z7Jrw-niKqfMIM00a3BtyQHaHf?w=134&h=180&c=7&r=0&o=5&dpr=1.1&pid=1.7.jpg',
'https://th.bing.com/th/id/OIP.KPVOR_NinhpH9_SGVMQ2jgHaLH?w=115&h=180&c=7&r=0&o=5&dpr=1.1&pid=1.7.jpg'
]
for item in url_list:
download_image(item)
输出：
- 协程方式（异步操作）
此方法会快，因为在对第一个url发送请求，然后IO，这个过程是有等待时间的，他不会闲着，而是立刻对第二个url发送请求，然后第二个也IO了，有等待时间，立即对第三个url发送请求。（也就是说发送过去下载请求，但其实没有下载完，等待着下载好保存到本地；一下发出去三个请求再下载，因为请求也是有时间的，与其交互的请求时间越长此方法速度快的越明显！从结果中我们也能看到）
"""
下载图片使用第三方模块aiohttp，请提前安装: pip3 install aiohttp
"""
# -*- coding:utf-8 -*-
import aiohttp
import asyncio
async def fetch(session, url):
print("发送请求: ", url)
async with session.get(url, verify_ssl=False) as response:
content = await response.content.read()
file_name = url.rsplit('/', 1)[-1]
with open(file_name, mode='wb') as file_object:
file_object.write(content)
print('下载完成', url)
async def main():
async with aiohttp.ClientSession() as session:
url_list = [
'https://th.bing.com/th/id/OIP.7TR2k4QU06TiowN6oiuZAAHaGk?w=195&h=180&c=7&r=0&o=5&dpr=1.1&pid=1.7.jpg',
'https://th.bing.com/th/id/OIP.Z7Jrw-niKqfMIM00a3BtyQHaHf?w=134&h=180&c=7&r=0&o=5&dpr=1.1&pid=1.7.jpg',
'https://th.bing.com/th/id/OIP.KPVOR_NinhpH9_SGVMQ2jgHaLH?w=115&h=180&c=7&r=0&o=5&dpr=1.1&pid=1.7.jpg'
]
tasks = [asyncio.create_task(fetch(session, url)) for url in url_list]
await asyncio.wait(tasks)
if __name__ == '__main__':
asyncio.run(main())
输出：
补充知识：
- 同步：排队完成任务叫同步
- 异步：任务不等结果，继续执行其他的，叫异步；所以python是以协程方式实现的异步编程
异步编程
事件循环
理解成为一个死循环，去检测并执行某些代码。或叫时间循环（每次去检测任务列表中的可执行和可完成的任务 对可执行任务进行执行 对已完成任务把它从任务列表中删除掉）
# 伪代码
任务列表 = [任务 1, 任务 2, 任务 3...]
while True:
可执行的任务列表，已完成的任务列表 = 去任务列表中检查所有的任务，将‘可执行’和‘已完成’的任务返回
for 就绪任务 in 可执行的任务列表:
执行已就绪的任务
for 已完成的任务 in 已完成的任务列表:
在任务列表中移除 已完成的任务
如果 任务列表 中的任务都已完成，则终止循环
那么就相当于
import asyncio
# 去生成或获取一个事件循环
loop = asyncio.get_event_loop()
# 将任务放到‘任务列表’
loop.run_until_complete(任务)
基本框架
什么是协程函数？
协程函数，定义函数时候 async def 函数名 。
协程对象，执行 协程函数()得到的协程对象。
async def func(): # 协程函数
pass
result = func() # 协程对象
注意：执行协程函数创建协程对象，函数内部代码不会执行。
如果想要运行协程函数内部代码，必须要讲协程对象交给事件循环来处理。
import asyncio
async def func():
print("666！")
result = func()
# loop = asyncio.get_event_loop()
# loop.run_until_complete( result )
# 或者可以写成
asyncio.run( result ) # >=python3.7
输出：666！
await详解
await + 可等待的对象（协程对象、Future、Task对象 ->IO等待）
示例1:
import asyncio
async def func():
print("来玩呀")
response = await asyncio.sleep(2) # 这里表示他会停下来此IO，然后对于其它的IO就会在这段时间内执行了
print("结束",response)
asyncio.run( func() )
输出：
来玩呀
然后等待这个sleep(2)再打印
结束 None
None的原因是await后的操作为sleep，没有意义，所以返回的None！
示例2：
import asyncio
async def others():
print("start")
await asyncio.sleep(2)
print("end")
return '返回值'
async def func():
print("执行协程函数内部代码")
# 遇到IO操作挂起当前协程（任务），等IO操作完成之后再继续往下执行。当前协程挂起时，事件循环可以去执行其他协程（任务）。
response = await others()
print("IO请求结束，结果为: ", response)
asyncio.run( func() )
输出：
示例3：
await只会切换到其他的协程函数里面，而对于自己是同步，也就是顺序执行的：
import asyncio
async def others():
print("start")
await asyncio.sleep(2)
print("end")
return '返回值'
async def func():
print("执行协程函数内部代码")
# 遇到IO操作挂起当前协程（任务），等IO操作完成之后再继续往下执行。当前协程挂起时，事件循环可以去执行其他协程（任务）。
response1 = await others()
print("IO请求结束，结果为: ", response1)
response2 = await others()
print("IO请求结束，结果为: ", response2)
asyncio.run( func() )
输出：
await就是等待对象的值得到结果之后再继续向下走。
（因为这个例子只有一个协程对象，所以看起来没实现异步，但有多个协程对象的时候，就可以在多个函数里面跳来跳去了）
Task对象
Task用于同时调度协程。
当协程被包裏在带有 asyncio.create_task()等函数的Task中时，协程会自动被安排尽快运行。
白话: 在事件循环中添加多个任务的。
Tasks用于并发调度协程，通过asyncio.create_task(协程对象)的方式创建Task对象，这样可以让协程加入事件循环中等待被调度执行。除了使用asyncio.create_task()函数以外，还可以用低级层的loop.create_task()或ensure_future()函数。不建议手动实例化Task对象。
注意: asyncio.create_task()函数在Python 3.7中被加入。在Python 3.7之前，可以改用低级层的asyncio.ensure_future()函数。
示例1：
import asyncio
async def func():
print(1)
await asyncio.sleep(2)
print(2)
return "返回值"
async def main():
print("main开始")
# 创建Task对象，将当前执行func函数任务添加到事件循环。
task1 = asyncio.create_task(func())
# 创建Task对象，将当前执行func函数任务添加到事件循环。
task2 = asyncio.create_task(func())
print("main结束")
# 当执行某协程遇到IO操作时，会自动化切换执行其他任务。
# 此处的await是等待相对应的协程全都执行完毕并获取结果
# await task1 并不是执行task1，而是一遇到await就切换到其他协程对象执行了
ret1 = await task1
ret2 = await task2
print(ret1, ret2)
asyncio.run(main())
输出：
但我们通常不这样写而是下面
示例2：
import asyncio
async def func():
print(1)
await asyncio.sleep(2)
print(2)
return "返回值"
async def main():
print("main开始")
task_list = [
asyncio.create_task(func(), name='n1'), # 将其立即加到事件循环
asyncio.create_task(func(), name='n2')
]
print("main结束")
# done是所有任务的返回值的集合；pending是所有任务的未完成的部分
done, pending = await asyncio.wait(task_list, timeout=None)
print(done)
asyncio.run(main()) # 事件循环已经创建
输出：
asyncio.Future对象
Future 是一个特殊的低级别 awaitable 对象，表示异步操作的最终结果。
Task继承Future，Task对象内部await结果的处理基于Future对象来的。
示例1（不要执行）：
async def main():
# 获取当前事件循环
loop = asyncio.get_running_loop()
# 创建一个任务（Future对象），这个任务什么都不干。
fut = loop.create_future()
# 等待任务最终结果（Future对象），没有结果则会一直等下去。
await fut
asyncio.run(main())
示例2：
import asyncio
async def set_after(fut):
await asyncio.sleep(2)
fut.set_result("666")
async def main():
# 获取当前事件循环
loop = asyncio.get_running_loop()
# 创建一个任务（Future对象），没绑定任何行为，则这个任务永远不知道什么时候结束。
fut = loop.create_future()
# 创建一个任务（Task对象），绑定了set_after函数，函数内部在2s之后，会给fut赋值。
# 即手动设置future任务的最终结果，那么fut就可以结束了。
await loop.create_task( set_after(fut) )
# 等待 Future对象获取 最终结果，否则一直等下去
data = await fut
print(data)
asyncio.run(main())
输出：
2s后输出666
但我们几乎不会用future对象，用的都是task对象。
concurrent.futures.Future对象
与上一个Future对象没有任何关系。
concurrent.futures.Future是使用线程池、进程池实现异步操作时用到的对象。
import time
from concurrent.futures import Future
from concurrent.futures.thread import ThreadPoolExecutor
from concurrent.futures.process import ProcessPoolExecutor
def func(value):
time.sleep(1)
print(value)
return 123
# 创建线程池
pool = ThreadPoolExecutor(max_workers=5)
# 创建进程池
# pool = ProcessPoolExecutor(max_workers=5)
for i in range(10):
fut = pool.submit(func, i)
print(fut)
输出：
为什么会这样？因为以后写代码可能会存在交叉使用。例如: crm项目80%都是基于协程异步编程 + MySQL (不支持) 【线程、进程做异步编程】。
也就是说支持async/await关键字的操作就用协程，不支持的就用concurrent。
这样既支持了异步的操作，又让他内部通过线程进行了线程操作；
基于协程或者说进程/线程池的异步：
import time
import asyncio
import concurrent.futures
def func1():
# 某个耗时操作
time.sleep(2)
return "SSS"
async def main():
loop = asyncio.get_running_loop()
# 1. Run in the default loop's executor ( 默认ThreadPoolExecutor )
# 第一步: 内部会先调用 ThreadPoolExecutor 的 submit 方法去线程池中申请一个线程去执行func1函数, 并返回一个concurrent.futures.Future对象
# 第二步: 调用asyncio.wrap_future将concurrent.futures.Future对象包装为asyncio.Future对象。
# 因为concurrent.futures.Future对象不支持await语法, 所以需要包装为 asyncio.Future对象 才能使用。
fut = loop.run_in_executor(None, func1)
result = await fut
print('default thread pool', result)
# 使用进程：
# 2. Run in a custom thread pool:
# with concurrent.futures.ThreadPoolExecutor() as pool: # 线程池
# result = await loop.run_in_executor(
# pool, func1)
# print('custom thread pool', result)
# 3. Run in a custom process pool:
# with concurrent.futures.ProcessPoolExecutor() as pool: # 进程池
# result = await loop.run_in_executor(
# pool, func1)
# print('custom process pool', result)
asyncio.run(main())
示例：
asyncio+不支持异步的模块（比如此例子的requests）
import asyncio
import requests
async def download_image(url):
# 发送网络请求，下载图片（遇到网络下载图片的IO请求，自动化切换到其他任务）
print("开始下载:", url)
loop = asyncio.get_event_loop()
# requests模块默认不支持异步操作，所以就使用线程池来配合实现了。
future = loop.run_in_executor(None, requests.get, url)
response = await future
print('下载完成')
# 图片保存到本地文件
file_name = url.rsplit('/', 1)[-1]
with open(file_name, mode='wb') as file_object:
file_object.write(response.content)
if __name__ == '__main__':
url_list = [
'https://th.bing.com/th/id/OIP.7TR2k4QU06TiowN6oiuZAAHaGk?w=195&h=180&c=7&r=0&o=5&dpr=1.1&pid=1.7.jpg',
'https://th.bing.com/th/id/OIP.Z7Jrw-niKqfMIM00a3BtyQHaHf?w=134&h=180&c=7&r=0&o=5&dpr=1.1&pid=1.7.jpg',
'https://th.bing.com/th/id/OIP.KPVOR_NinhpH9_SGVMQ2jgHaLH?w=115&h=180&c=7&r=0&o=5&dpr=1.1&pid=1.7.jpg'
]
tasks = [asyncio.create_task(download_image(url)) for url in url_list]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
输出：
异步迭代器（不常用）
了解即可，不常用，也不影响我们对于异步编程的大部分使用。
什么是异步迭代器？
实现了 __aiter__() 和 __anext__() 方法的对象。__anext__ 必须返回一个 awaitable 对象。async for 会处理异步迭代器的 __anext__() 方法所返回的可等待对象，直到其引发一个 StopAsyncIteration 异常
什么是异步可迭代对象?
可在 async for 语句中被使用的对象。必须通过它的 __aiter__() 方法返回一个 asynchronous iterator。
import asyncio
class Reader(object):
""" 自定义异步迭代器（同时也是异步可迭代对象） """
def __init__(self):
self.count = 0
async def readline(self):
# await asyncio.sleep(1)
self.count += 1
if self.count == 100:
return None
return self.count
def __aiter__(self):
return self
async def __anext__(self):
val = await self.readline()
if val == None:
raise StopAsyncIteration
return val
async def func():
obj = Reader()
async for item in obj:
print(item)
asyncio.run(func())
异步上下文管理器（不常用）
此方法也不常用了解即可
此种对象通过定义__aenter __()和 __aexit __()方法来对 async _with 语句中的环境进行控制。
import asyncio
class AsyncContextManager:
def __init__(self):
self.conn = None # 这里先简单初始化为None，实际应根据数据库连接逻辑修改
async def do_something(self):
# 异步操作数据库
return 666
async def __aenter__(self):
# 异步链接数据库
await asyncio.sleep(1)
self.conn = "模拟已连接数据库" # 这里简单模拟已连接数据库，实际应是真实连接操作
return self
async def __aexit__(self, exc_type, exc, tb):
# 异步关闭数据库链接
await asyncio.sleep(1)
self.conn = None # 模拟关闭数据库连接
async def func():
async with AsyncContextManager() as f:
result = await f.do_something()
print(result)
asyncio.run(func())
输出：
666
uvloop
是asyncio的事件循环的替代方案。此事件循环>默认asyncio的事件循环
注意：uvloop目前不支持Windows
import asyncio
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
# 编写asyncio的代码，与之前写的代码一致。
# 内部的事件循环自动化会变为uvloop
asyncio.run(...)
案例
案例这里只写思想方法，不写执行结果和输出，我们重点学习的是如何看懂异步操作，当然对于异步爬虫我会重点讲下，因为他常用好用大家都喜欢用！
案例1：异步操作redis
（但不如搞连接池）
在使用python代码操作redis时，链接/操作/断开都是网络IO
示例1：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import asyncio
import aioredis
async def execute(address, password):
print("开始执行", address)
# 网络IO操作: 创建redis连接
redis = await aioredis.create_redis(address, password=password)
# 网络IO操作: 在redis中设置哈希值car，内部设三个键值对，即: redis = { car: {key1:1,key2:2,key3:3}}
await redis.hmset_dict('car', key1=1, key2=2, key3=3)
# 网络IO操作: 去redis中获取值
result = await redis.hgetall('car', encoding='utf-8')
print(result)
redis.close()
# 网络IO操作: 关闭redis连接
await redis.wait_closed()
print("结束", address)
asyncio.run(execute('redis://xx.xx.x.xxx:xxxx', "密码"))
示例2：
import asyncio
import aioredis
async def execute(address, password):
print("开始执行", address)
# 网络IO操作: 先去连接 47.93.4.197:6379，遇到IO则自动切换任务，去连接47.93.4.198:6379
redis = await aioredis.create_redis_pool(address, password=password)
# 网络IO操作: 遇到IO会自动切换任务
await redis.hmset_dict('car', key1=1, key2=2, key3=3)
# 网络IO操作: 遇到IO会自动切换任务
result = await redis.hgetall('car', encoding='utf-8')
print(result)
redis.close()
# 网络IO操作: 遇到IO会自动切换任务
await redis.wait_closed()
print("结束", address)
task_list = [
execute('redis://47.93.4.197:6379', "密码"),
execute('redis://47.93.4.198:6379', "密码")
]
asyncio.run(asyncio.wait(task_list))
案例2：异步操作MySQL
示例1：
import asyncio
import aiomysql
async def execute():
# 网络IO操作: 连接MySQL
conn = await aiomysql.connect(host='127.0.0.1', port=3306, user='root', password='密码', db='mysql')
# 网络IO操作: 创建CURSOR
cur = await conn.cursor()
# 网络IO操作: 执行SQL
await cur.execute("SELECT Host,User FROM user")
# 网络IO操作: 获取SQL结果
result = await cur.fetchall()
print(result)
# 网络IO操作: 关闭链接
await cur.close()
conn.close()
asyncio.run(execute())
示例2：
import asyncio
import aiomysql
async def execute(host, password):
print("开始", host)
# 网络IO操作: 先去连接 47.93.40.197，遇到IO则自动切换任务，去连接47.93.40.198
conn = await aiomysql.connect(host=host, port=3306, user='root', password=password, db='mysql')
# 网络IO操作: 遇到IO会自动切换任务
cur = await conn.cursor()
# 网络IO操作: 遇到IO会自动切换任务
await cur.execute("SELECT Host,User FROM user")
# 网络IO操作: 遇到IO会自动切换任务
result = await cur.fetchall()
print(result)
# 网络IO操作: 遇到IO会自动切换任务
await cur.close()
conn.close()
print("结束", host)
task_list = [
execute('47.93.41.197', "密码"),
execute('47.93.40.197', "密码")
]
asyncio.run(asyncio.wait(task_list))
案例3：FastAPI框架为例
安装
pip3 install fastapi
pip3 install uvicorn (asgi内部基于uvloop)
在IO等待的时候会立马执行其余的，一个线程能接受两个并发
此python文件名：luffy.py
import asyncio
import uvicorn
import aioredis
from aioredis import Redis
from fastapi import FastAPI
app = FastAPI()
REDIS_POOL = aioredis.ConnectionPool('redis://47.193.14.198:6379', password="密码", minsize=1, maxsize=10)
@app.get("/")
def index():
""" 普通操作接口 """
return {"message": "Hello world"}
@app.get("/red")
async def red():
""" 异步操作接口 """
print("请求来了")
await asyncio.sleep(3)
# 连接池获取一个连接
conn = await REDIS_POOL.acquire()
redis = Redis(conn)
# 设置值
await redis.hmset_dict('car', key1=1, key2=2, key3=3)
# 读取值
result = await redis.hgetall('car', encoding='utf-8')
print(result)
# 连接归还连接池
REDIS_POOL.release(conn)
return result
if __name__ == '__main__':
uvicorn.run("luffy:app", host="127.0.0.1", port=5000, log_level="info")
案例4：异步爬虫
import aiohttp
import asyncio
async def fetch(session, url):
print("发送请求: ", url)
async with session.get(url, verify_ssl=False) as response:
text = await response.text()
print("得到结果: ", url, len(text))
async def main():
async with aiohttp.ClientSession() as session:
url_list = [
'https://www.python.org',
'https://www.baidu.com',
'https://www.bing.com'
]
tasks = [asyncio.create_task(fetch(session, url)) for url in url_list]
await asyncio.wait(tasks)
if __name__ == '__main__':
asyncio.run(main())
输出：
从结果中我们能发现发送请求属于并发的，因为请求一定会比IO访问快！然后再回执行各个的数据交换结果，由于我人在国外，对于国外构建的python和bing网站是比访问国内构建的baidu网站速度快的，所以得到结果应该是这两者最先完成，从我们的输出结果中就不难看出是这样的！这下你更能清楚的发现异步操作，并不是像我们那样的同步操作执行的。
代码解析：
- 导入模块：
aiohttp是一个用于异步处理HTTP请求的库，它基于asyncio实现异步I/O操作，能高效地处理大量并发HTTP请求。asyncio是Python的异步编程库，提供异步任务管理、事件循环等功能。
- 定义
fetch函数：- 这是一个异步函数，接收一个
aiohttp.ClientSession对象和一个URL作为参数。 - 首先打印发送请求的URL信息。
- 使用
async with语句异步发起HTTP GET请求，设置verify_ssl=False表示不验证SSL证书（在生产环境需谨慎使用，建议正确配置SSL证书验证 ）。 - 通过
response.text()异步获取响应内容，并打印得到结果的URL和响应内容的长度。
- 这是一个异步函数，接收一个
- 定义
main函数：- 同样是异步函数，使用
async with创建一个aiohttp.ClientSession会话对象。 - 定义一个包含多个URL的列表
url_list。 - 使用列表推导式为每个URL创建一个异步任务
fetch(session, url)，并将这些任务包装成asyncio.Task对象，存入tasks列表。 - 最后使用
await asyncio.wait(tasks)等待所有任务完成。
- 同样是异步函数，使用
- 程序入口：
- 在
if __name__ == '__main__':条件块中，使用asyncio.run(main())来运行main异步函数，启动整个异步操作流程。
- 在
此篇文章纪念博主破千收藏，感谢各位支持！感谢观看！
扫一扫
129
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
