@BBCCBB 是呀，我本来是想着，并发执行多个 sql，这样将整体查询时长降低至最长查询的那个 sql 。但是感觉并没有达到预期的效果

@BBCCBB 其实最大的需求，还是提升响应效率了，这个查询 2s 多能降到 1s 多，甚至不到 1s，就是最高的期望值了，但是测试感觉难以实现

class Pmysql:

def __init__(self):
self.conn = None
self.pool = None

async def initpool(self):
try:
__pool = await aiomysql.create_pool(minsize=10,
maxsize=10,
host=Config.host,
port=Config.port,
user=Config.user,
password=Config.password,
db='db')
return __pool
except Exception as e:
print(e)
print('create connect error.')

async def getCursor(self):
conn = await self.pool.acquire()
cur = await conn.cursor()
return conn, cur

async def query(self, query, param=None):
conn, cur = await self.getCursor()
try:
await cur.execute(query, param)
return await cur.fetchall()
except:
print('error')
finally:
if cur:
await cur.close()
await self.pool.release(conn)

async def getAmysqlobj():
mysqlobj = Pmysql()
pool = await mysqlobj.initpool()
mysqlobj.pool = pool
return mysqlobj

@BBCCBB gather 里面是顺序执行的吗？我看官方文档里是这样描述的：
同时运行 aws 序列中的可等待对象。

如果 aws 中的任何 awaitable 是协程，则它会自动安排为任务。

如果所有 awaitable 都成功完成，则结果是返回值的聚合列表。结果值的顺序对应于 aws 中等待的顺序。

如果 return_exceptions 为 False （默认），第一个引发的异常会立即传播到在 gather() 上等待的任务。aws 序列中的其他等待对象不会被取消，而是会继续运行。

如果 return_exceptions 为 True，则将异常视为成功结果，并在结果列表中聚合。

如果 gather() 被取消，所有提交的等待（尚未完成）也将被取消。

如果 aws 序列中的任何 Task 或 Future 被取消，则将其视为引发了 CancelledError - 在这种情况下不会取消 gather() 调用。这是为了防止取消一个提交的任务 /未来导致其他任务 /未来被取消。

@chaleaoch 淦，我调了 1000 次，同步 40 多秒，异步 5 秒多。问题生产环境中一个接口里面不可能会有这么高频次的查询，小频次的查询，同步异步的差距就很不明显

@v2exblog 试了试，差不多，timeit 测试了下跟同步查询的差不多，就感觉很奇怪

@pabupa mix 是 5，max 是 10，按理说应该够了，我调整一下试试

@BBCCBB 是的，这两种方式是写法的区别。 我的意思是：
fuction outside(){
asyncFucn1()
asyncFunc2()
asyncFunc3()
asycnFunc4()
......
}
如果 outside 函数等待里面异步函数结束退出的话，执行时长应该是内部异步函数执行时间最长的时长吧。那我同时发起 N 个 sql 查询，整体查询时长应该是 N 个查询 sql 中执行时长最长的时长吧

@chaleaoch 是呀，就是我指的就是 gather 里面的任务并发执行的话，执行时长应该是这里面最长执行任务的时长，而不是所有任务执行时长的累积

@chaleaoch await 语法糖的作用应该就是等待异步代码返回结果了吧，类似于回调。我想问的是 asyncio.gather()里面的任务不应该是并发执行的吗