Python aiohttp百萬并發極限測試實例分析

 更新時間:2019年10月26日 09:05:41   作者:孫大花   我要評論
這篇文章主要介紹了Python aiohttp百萬并發極限測試,結合實例形式分析了Python異步編程基于aiohttp客戶端高并發請求的相關操作技巧與使用注意事項,需要的朋友可以參考下

本文實例講述了Python aiohttp百萬并發極限測試。分享給大家供大家參考,具體如下:

本文將測試python aiohttp的極限,同時測試其性能表現,以分鐘發起請求數作為指標。大家都知道,當應用到網絡操作時,異步的代碼表現更優秀,但是驗證這個事情,同時搞明白異步到底有多大的優勢以及為什么會有這樣的優勢仍然是一件有趣的事情。為了驗證,我將發起1000000請求,用aiohttp客戶端。aiohttp每分鐘能夠發起多少請求?你能預料到哪些異常情況以及崩潰會發生,當你用比較粗糙的腳本去發起如此大量的請求?面對如此大量的請求,哪些主要的陷阱是你需要去思考的?

初識 asyncio/aiohttp

異步編程并不簡單。相比平常的同步編程,你需要付出更多的努力在使用回調函數,以事件以及事件處理器的模式進行思考。同時也是因為asyncio相對較新,相關的教程以及博客還很少的緣故。官方文檔非常簡陋,只有最基本的范例。在我寫本文的時候,Stack Overflow上面,只有410個與asyncio相關的話題(相比之下,twisted相關的有2585)。有個別關于asyncio的不錯的博客以及文章,比如這個這個這個,或者還有這個以及這個

簡單起見,我們先從基礎開始 —— 簡單HTTP hello world —— 發起GET請求,同時獲取一個單獨的HTTP響應。

同步模式,你這么做:

import requests
def hello()
   return requests.get("http://httpbin.org/get")
print(hello())

接著我們使用aiohttp:

#!/usr/local/bin/python3.5
import asyncio
from aiohttp import ClientSession
async def hello():
  async with ClientSession() as session:
    async with session.get("http://httpbin.org/headers") as response:
      response = await response.read()
      print(response)
loop = asyncio.get_event_loop()
loop.run_until_complete(hello())

好吧,看上去僅僅一個簡單的任務,我寫了很多的代碼……那里有“async def”、“async with”、“await”—— 看上去讓人迷惑,讓我們嘗試弄懂它們。

你使用async以及await關鍵字將函數異步化。在hello()中實際上有兩個異步操作:首先異步獲取相應,然后異步讀取響應的內容。

Aiohttp推薦使用ClientSession作為主要的接口發起請求。ClientSession允許在多個請求之間保存cookie以及相關對象信息。Session(會話)在使用完畢之后需要關閉,關閉Session是另一個異步操作,所以每次你都需要使用async with關鍵字。

一旦你建立了客戶端session,你可以用它發起請求。這里是又一個異步操作的開始。上下文管理器的with語句可以保證在處理session的時候,總是能正確的關閉它。

要讓你的程序正常的跑起來,你需要將他們加入事件循環中。所以你需要創建一個asyncio loop的實例, 然后將任務加入其中。

看起來有些困難,但是只要你花點時間進行思考與理解,就會有所體會,其實并沒有那么復雜。

訪問多個鏈接

現在我們來做些更有意思的事情,順序訪問多個鏈接。

同步方式如下:

for url in urls:
  print(requests.get(url).text)

很簡單。不過異步方式卻沒有這么容易。所以任何時候你都需要思考,你的處境是否有必要用到異步。如果你的app在同步模式工作的很好,也許你并不需要將之遷移到異步方式。如果你確實需要異步方式,這里會給你一些啟示。我們的異步函數hello()還是保持原樣,不過我們需要將之包裝在asyncio的Future對象中,然后將Future對象列表作為任務傳遞給事件循環。

loop = asyncio.get_event_loop()
tasks = [] # I'm using test server localhost, but you can use any url
url = "http://localhost:8080/{}"
for i in range(5):
  task = asyncio.ensure_future(hello(url.format(i)))
  tasks.append(task)
loop.run_until_complete(asyncio.wait(tasks))

現在假設我們想獲取所有的響應,并將他們保存在同一個列表中。目前,我們沒有保存響應內容,僅僅只是打印了他們。讓我們返回他們,將之存儲在一個列表當中,最后再打印出來。

為了達到這個目的,我們需要修改一下代碼:

#!/usr/local/bin/python3.5
import asyncio
from aiohttp import ClientSession
async def fetch(url):
  async with ClientSession() as session:
   async with session.get(url) as response:
     return await response.read()
async def run(loop, r):
  url = "http://localhost:8080/{}"
  tasks = []
  for i in range(r):
    task = asyncio.ensure_future(fetch(url.format(i)))
    tasks.append(task)
    responses = await asyncio.gather(*tasks)
    # you now have all response bodies in this variable
    print(responses)
def print_responses(result):
  print(result)
loop = asyncio.get_event_loop()
future = asyncio.ensure_future(run(loop, 4))
loop.run_until_complete(future)

注意asyncio.gather()的用法,它搜集所有的Future對象,然后等待他們返回。

常見錯誤

現在我們來模擬真實場景,去調試一些錯誤,作為演示范例。

看看這個:

# WARNING! BROKEN CODE DO NOT COPY PASTE
async def fetch(url):
  async with ClientSession() as session:
   async with session.get(url) as response:
     return response.read()

如果你對aiohttp或者asyncio不夠了解,即使你很熟悉Python,這段代碼也不好debug。

上面的代碼產生如下輸出:

[email protected] ~/p/l/benchmarker> ./bench.py
[<generator object ClientResponse.read at 0x7fa68d465728>,
 <generator object ClientResponse.read at 0x7fa68cdd9468>,
 <generator object ClientResponse.read at 0x7fa68d4656d0>,
 <generator object ClientResponse.read at 0x7fa68cdd9af0>]

發生了什么?你期待獲得響應對象,但是你得到的是一組生成器。怎么會這樣?

我之前提到過,response.read()是一個異步操作,這意味著它不會立即返回結果,僅僅返回生成器。這些生成器需要被調用跟運行,但是這并不是默認行為。在Python34中加入的yield from以及Python35中加入的await便是為此而生。它們將迭代這些生成器。以上代碼只需要在response.read()前加上await關鍵字即可修復。如下:

  # async operation must be preceded by await
  return await response.read()
  # NOT: return response.read()

我們看看另一個例子。

# WARNING! BROKEN CODE DO NOT COPY PASTE
async def run(loop, r):
  url = "http://localhost:8080/{}"
  tasks = []
  for i in range(r):
    task = asyncio.ensure_future(fetch(url.format(i)))
    tasks.append(task)
    responses = asyncio.gather(*tasks)
    print(responses)

輸出結果如下:

[email protected] ~/p/l/benchmarker> ./bench.py
<_GatheringFuture pending>
Task was destroyed but it is pending!
task: <Task pending coro=<fetch() running at ./bench.py:7>
        wait_for=<Future pending cb=[Task._wakeup()]>
        cb=[gather.<locals>._done_callback(0)()
        at /usr/local/lib/python3.5/asyncio/tasks.py:602]>
Task was destroyed but it is pending!
task: <Task pending coro=<fetch() running at ./bench.py:7>
  wait_for=<Future pending cb=[Task._wakeup()]>
  cb=[gather.<locals>._done_callback(1)()
  at /usr/local/lib/python3.5/asyncio/tasks.py:602]>
Task was destroyed but it is pending!
task: <Task pending coro=<fetch() running at ./bench.py:7>
  wait_for=<Future pending cb=[Task._wakeup()]>
  cb=[gather.<locals>._done_callback(2)()
  at /usr/local/lib/python3.5/asyncio/tasks.py:602]>
Task was destroyed but it is pending!
task: <Task pending coro=<fetch() running at ./bench.py:7>
  wait_for=<Future pending cb=[Task._wakeup()]>
  cb=[gather.<locals>._done_callback(3)()
  at /usr/local/lib/python3.5/asyncio/tasks.py:602]>

發生了什么?查看本地日志,你會發現沒有任何請求到達服務器,實際上沒有任何請求發生。打印信息首先打印<_Gathering pending>對象,然后警告等待的任務被銷毀。又一次的,你忘記了await。

修改

responses = asyncio.gather(*tasks)

responses = await asyncio.gather(*tasks)

即可解決問題。

經驗:任何時候,你在等待什么的時候,記得使用await。

同步 vs 異步

重頭戲來了。我們來驗證異步是否值得(編碼麻煩)。看看同步與異步(client)效率上的區別。異步每分鐘能夠發起多少請求。

為此,我們首先配置一個異步的aiohttp服務器端。這個服務端將獲取全部的html文本, 來自Marry Shelley的Frankenstein。在每個響應中,它將添加隨機的延時。有的為0,最大值為3s。類似真正的app。有些app的響應延時為固定值,一般而言,每個響應的延時是不同的。

服務器代碼如下:

#!/usr/local/bin/python3.5
import asyncio
from datetime import datetime
from aiohttp import web
import random
# set seed to ensure async and sync client get same distribution of delay values
# and tests are fair random.seed(1)
async def hello(request):
  name = request.match_info.get("name", "foo")
  n = datetime.now().isoformat()
  delay = random.randint(0, 3)
  await asyncio.sleep(delay)
  headers = {"content_type": "text/html", "delay": str(delay)}
  # opening file is not async here, so it may block, to improve
  # efficiency of this you can consider using asyncio Executors
  # that will delegate file operation to separate thread or process
  # and improve performance
  # https://docs.python.org/3/library/asyncio-eventloop.html#executor
  # https://pymotw.com/3/asyncio/executors.html
  with open("frank.html", "rb") as html_body:
     print("{}: {} delay: {}".format(n, request.path, delay))
     response = web.Response(body=html_body.read(), headers=headers)
     return response
app = web.Application()
app.router.add_route("GET", "/{name}", hello)
web.run_app(app)

同步客戶端代碼如下:

import requests
r = 100
url = "http://localhost:8080/{}"
for i in range(r):
  res = requests.get(url.format(i))
 delay = res.headers.get("DELAY")
 d = res.headers.get("DATE")
 print("{}:{} delay {}".format(d, res.url, delay))

在我的機器上,上面的代碼耗時2分45s。而異步代碼只需要3.48s。

有趣的是,異步代碼耗時無限接近最長的延時(server的配置)。如果你觀察打印信息,你會發現異步客戶端的優勢有多么巨大。有的響應為0延遲,有的為3s。同步模式下,客戶端會阻塞、等待,你的機器什么都不做。異步客戶端不會浪費時間,當有延遲發生時,它將去做其他的事情。在日志中,你也會發現這個現象。首先是0延遲的響應,然后當它們到達后,你將看到1s的延遲,最后是最大延遲的響應。

極限測試

現在我們知道異步表現更好,讓我們嘗試去找到它的極限,同時嘗試讓它崩潰。我將發送1000異步請求。我很好奇我的客戶端能夠處理多少數量的請求。

> time python3 bench.py
2.68user 0.24system 0:07.14elapsed 40%CPU
(0avgtext+0avgdata 53704maxresident)
k 0inputs+0outputs (0major+14156minor)pagefaults 0swaps


1000個請求,花費了7s。相當不錯的成績。然后10K呢?很不幸,失敗了:

responses are <_GatheringFuture finished exception=
  ClientOSError(24, 'Cannot connect to host localhost:8080 ssl:
  False [Can not connect to localhost:8080 [Too many open files]]')>
Traceback (most recent call last):
   File "/home/pawel/.local/lib/python3.5/site-packages/aiohttp/connector.py", line 581, in _create_connection
   File "/usr/local/lib/python3.5/asyncio/base_events.py", line 651, in create_connection
   File "/usr/local/lib/python3.5/asyncio/base_events.py", line 618, in create_connection
   File "/usr/local/lib/python3.5/socket.py", line 134, in __init__ OS
   Error: [Errno 24] Too many open files

這樣不大好,貌似我倒在了10K connections problem面前。

traceback顯示,open files太多了,可能代表著open sockets太多。為什么叫文件?Sockets(套接字)僅僅是文件描述符,操作系統有數量的限制。多少才叫太多呢?我查看Python源碼,然后發現這個值為1024.怎么樣繞過這個問題?一個粗暴的辦法是增加這個數值,但是聽起來并不高明。更好的辦法是,加入一些同步機制,限制并發數量。于是我在asyncio.Semaphore()中加入最大任務限制為1000.

修改客戶端代碼如下:

# modified fetch function with semaphore
import random
import asyncio
from aiohttp import ClientSession
async def fetch(url):
  async with ClientSession() as session:
    async with session.get(url) as response:
     delay = response.headers.get("DELAY")
     date = response.headers.get("DATE")
     print("{}:{} with delay {}".format(date, response.url, delay))
     return await response.read()
async def bound_fetch(sem, url):
  # getter function with semaphore
  async with sem:
   await fetch(url)
  async def run(loop, r):
   url = "http://localhost:8080/{}"
   tasks = []
   # create instance of Semaphore
   sem = asyncio.Semaphore(1000)
   for i in range(r):
     # pass Semaphore to every GET request
     task = asyncio.ensure_future(bound_fetch(sem, url.format(i)))
     tasks.append(task)
     responses = asyncio.gather(*tasks)
await responses number = 10000
loop = asyncio.get_event_loop()
future = asyncio.ensure_future(run(loop, number))
loop.run_until_complete(future)

現在,我們可以處理10k鏈接了。這花去我們23s,同時返回了一些異常。不過不管怎樣,相當不錯的表現。

那100K呢?這個任務讓我的機器很吃力,不過驚奇的是,它工作的很好。服務器的表現相當穩定,雖然內存占用很高,然后cpu占用一直維持在100%左右。讓我覺得有趣的是,服務器占用的cpu明顯小于client。這是ps的回顯:

[email protected] ~/p/l/benchmarker> ps ua | grep python
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
pawel     2447 56.3  1.0 216124 64976 pts/9    Sl+  21:26   1:27 /usr/local/bin/python3.5 ./test_server.py
pawel     2527  101  3.5 674732 212076 pts/0   Rl+  21:26   2:30 /usr/local/bin/python3.5 ./bench.py

最終因為某些原因,運行5分鐘過后,它崩潰了。它生成了接近100K行的輸出,所以很難定位traceback,好像某些響應沒有正常關閉。具體原因不太確定。(client or server error)

一段時間的滾動以后,我找到了這個異常,在client日志中。

  File "/usr/local/lib/python3.5/asyncio/futures.py", line 387, in __iter__
      return self.result()  # May raise too.
  File "/usr/local/lib/python3.5/asyncio/futures.py", line 274, in result
       raise self._exception
  File "/usr/local/lib/python3.5/asyncio/selector_events.py", line 411, in _sock_connect
       sock.connect(address) OS
  Error: [Errno 99] Cannot assign requested address

我不太確定這里發生了什么。我初始的猜測是測試服務器掛掉了。一個讀者提出:這個異常的發生原因是操作系統的可用端口耗盡。之前我限制了并發連接數最大為1k,可能有些sockets仍然處在closing狀態,系統內核無法使用才導致這個問題。

已經很不錯了,不是嗎?100k耗時5分鐘。相當于一分鐘20k請求數。

最后我嘗試1M連接數。我真怕我的筆記本因為這個爆炸^_^.我特意將延遲降低為0到1s之間。最終耗時52分鐘。

1913.06user 1196.09system 52:06.87elapsed 99%CPU
(0avgtext+0avgdata 5194260maxresident)k 265144
inputs+0outputs (18692major+2528207minor)
pagefaults 0swaps

這意味著,我們的客戶端每分鐘發送了19230次請求。還不錯吧?注意客戶端的性能被服務器限制了,好像服務器端崩潰了好幾次。

最后

如你所見,異步HTTP客戶端相當強大。發起1M請求不是那么困難,同時相比同步模式,優勢巨大。

我好奇對比其他的語言或者異步框架,其表現如何?可能在以后某個時候,我將對比Twisted Treq跟aiohttp。然后,其他的異步庫(其他語言)能夠支持到多少并發?比如:某些Java 異步框架?或者C++框架?或者某些Rust HTTP客戶端?

更多關于Python相關內容感興趣的讀者可查看本站專題:《Python進程與線程操作技巧總結》、《Python數據結構與算法教程》、《Python函數使用技巧總結》、《Python字符串操作技巧匯總》、《Python入門與進階經典教程》、《Python+MySQL數據庫程序設計入門教程》及《Python常見數據庫操作技巧匯總

希望本文所述對大家Python程序設計有所幫助。

相關文章

  • python實現翻轉棋游戲(othello)

    python實現翻轉棋游戲(othello)

    這篇文章主要為大家詳細介紹了python實現翻轉棋游戲,具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2019-07-07
  • 對Python之gzip文件讀寫的方法詳解

    對Python之gzip文件讀寫的方法詳解

    今天小編就為大家分享一篇對Python之gzip文件讀寫的方法詳解,具有很好的參考價值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2019-02-02
  • Python之使用adb shell命令啟動應用的方法詳解

    Python之使用adb shell命令啟動應用的方法詳解

    今天小編就為大家分享一篇Python之使用adb shell命令啟動應用的方法詳解,具有很好的參考價值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2019-01-01
  • Python利用Nagios增加微信報警通知的功能

    Python利用Nagios增加微信報警通知的功能

    Nagios是一款開源的免費網絡監視工具,能有效監控Windows、Linux和Unix的主機狀態,交換機路由器等網絡設置,打印機等,本文給大家介紹Python利用Nagios增加微信報警通知的功能,需要的朋友參考下
    2016-02-02
  • python內存管理分析

    python內存管理分析

    這篇文章主要介紹了python內存管理,較為詳細的分析了Python的內存管理機制,需要的朋友可以參考下
    2015-04-04
  • Django命名URL和反向解析URL實現解析

    Django命名URL和反向解析URL實現解析

    這篇文章主要介紹了Django命名URL和反向解析URL實現解析,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
    2019-08-08
  • Python中字符串格式化str.format的詳細介紹

    Python中字符串格式化str.format的詳細介紹

    python從2.6開始支持format,新的更加容易讀懂的字符串格式化方法,下面這篇文章主要介紹了Python中字符串格式化str.format的相關資料,需要的朋友可以參考借鑒,下面來一起看看吧。
    2017-02-02
  • 跟老齊學Python之畫圈還不簡單嗎?

    跟老齊學Python之畫圈還不簡單嗎?

    畫圈?換一個說法就是循環。循環,是高級語言編程中重要的工作。現實生活中,很多事情都是在循環,日月更迭,斗轉星移,無不是循環;王朝更迭,尋常百姓,也都是循環。
    2014-09-09
  • python自然語言編碼轉換模塊codecs介紹

    python自然語言編碼轉換模塊codecs介紹

    這篇文章主要介紹了python自然語言編碼轉換模塊codecs介紹,codecs專門用作編碼轉換,通過它的接口是可以擴展到其他關于代碼方面的轉換,需要的朋友可以參考下
    2015-04-04
  • 對Python3中bytes和HexStr之間的轉換詳解

    對Python3中bytes和HexStr之間的轉換詳解

    今天小編就為大家分享一篇對Python3中bytes和HexStr之間的轉換詳解,具有很好的參考價值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2018-12-12

最新評論

福建体育彩票时时彩11