asyncio并发数_asyncio aiohttp限制并发数量和超时时间

importasyncioimportrandomimporttracebackfrom aiohttp importClientSession, TCPConnector, client_exceptionsimporttime

URL= 'http://127.0.0.1:5000/?delay={}'asyncdeffetch(session, i):

dly= random.randint(1,8)

url=URL.format(dly)

start_time=time.time()try:

async with session.get(url=url) as response:

r=await response.read()

end_time=time.time()

cost= end_time -start_time

msg= "第{}个查询请求，花费时间: {}s, 返回信息: {}\n".format(i, cost, r.decode('unicode-escape'))print("running %d" %i, msg)exceptclient_exceptions.ServerTimeoutError as timeout_error:print("request timeout error: {}, url: {}".format(timeout_error, url))exceptException as e:print("request unknown error: {}".format(traceback.format_exc()))

asyncdefchunks(sem, session, i):"""限制并发数"""

#使用Semaphore， 它会在第一批2000个请求发出且返回结果(是否等待返回结果取决于你的register_user方法的定义)后

#检查本地TCP连接池(最大2000个)的空闲数(连接池某个插槽是否空闲，在这里，取决于请求是否返回)

#有空闲插槽，就PUT入一个请求并发出(完全不同于Jmeter的rame up in period的线性发起机制).

#所以，在结果log里，你会看到第一批请求(开始时间)是同一秒发起，而后面的则完全取决于服务器的吞吐量

async with sem:

await fetch(session, i)

asyncdefrun(num):

tasks=[]#Semaphore， 相当于基于服务器的处理速度和测试客户端的硬件条件，一批批的发

#直至发送完全部(下面定义的number/num)

sem = asyncio.Semaphore(400)#创建session，且对本地的TCP连接不做限制limit=0

#超时时间指定

#total:全部请求最终完成时间

#connect: aiohttp从本机连接池里取出一个将要进行的请求的时间

#sock_connect：单个请求连接到服务器的时间

#sock_read：单个请求从服务器返回的时间

importaiohttp

timeout= aiohttp.ClientTimeout(total=330, connect=2, sock_connect=15, sock_read=10)

async with ClientSession(connector=TCPConnector(limit=400), timeout=timeout) as session:for i inrange(0, num):#如果是分批的发，就使用并传递Semaphore

task =asyncio.ensure_future(

chunks(sem, session, i))#register_user(session, i))

tasks.append(task)

responses= asyncio.gather(*tasks)

await responses

start=time.time()

number= 380loop=asyncio.get_event_loop()

future=asyncio.ensure_future(run(number))

loop.run_until_complete(future)

end=time.time()

total= end -start

with open("log", "a+", encoding="utf-8") as f:

f.write('总耗时：{}秒,平均速度：{}秒\n'.format(total, total / number))