Pythonで100,000のHTTPリクエストを送信する最も速い方法は何ですか？

100,000のURLを持つファイルを開いています。各URLにHTTPリクエストを送信し、ステータスコードを出力する必要があります。私はPython 2.6を使用していますが、これまでのところ、Pythonがスレッド化/並行処理を実装する多くの混乱する方法を見てきました。私はpythonの並行処理ライブラリも調べましたが、このプログラムを正しく作成する方法を理解できません。誰かが同様の問題に遭遇しましたか？私は一般に、Pythonで何千ものタスクを可能な限り高速に実行する方法を知る必要があると思います-それは「並行して」を意味すると思います。

ねじれのないソリューション：

from urlparse import urlparse
from threading import Thread
import httplib, sys
from Queue import Queue

concurrent = 200

def doWork():
    while True:
        url = q.get()
        status, url = getStatus(url)
        doSomethingWithResult(status, url)
        q.task_done()

def getStatus(ourl):
    try:
        url = urlparse(ourl)
        conn = httplib.HTTPConnection(url.netloc)   
        conn.request("HEAD", url.path)
        res = conn.getresponse()
        return res.status, ourl
    except:
        return "error", ourl

def doSomethingWithResult(status, url):
    print status, url

q = Queue(concurrent * 2)
for i in range(concurrent):
    t = Thread(target=doWork)
    t.daemon = True
    t.start()
try:
    for url in open('urllist.txt'):
        q.put(url.strip())
    q.join()
except KeyboardInterrupt:
    sys.exit(1)

これはツイストソリューションよりもわずかに高速で、CPU使用量も少なくなります。

トルネード非同期ネットワークライブラリを使用したソリューション

from tornado import ioloop, httpclient

i = 0

def handle_request(response):
    print(response.code)
    global i
    i -= 1
    if i == 0:
        ioloop.IOLoop.instance().stop()

http_client = httpclient.AsyncHTTPClient()
for url in open('urls.txt'):
    i += 1
    http_client.fetch(url.strip(), handle_request, method='HEAD')
ioloop.IOLoop.instance().start()

これが投稿された2010年以降、状況はかなり変化しており、他のすべての回答を試したことはありませんが、いくつか試しましたが、python3.6を使用すると、これが最もうまく機能することがわかりました。

AWSで実行されている毎秒約150の一意のドメインをフェッチできました。

import pandas as pd
import concurrent.futures
import requests
import time

out = []
CONNECTIONS = 100
TIMEOUT = 5

tlds = open('../data/sample_1k.txt').read().splitlines()
urls = ['http://{}'.format(x) for x in tlds[1:]]

def load_url(url, timeout):
    ans = requests.head(url, timeout=timeout)
    return ans.status_code

with concurrent.futures.ThreadPoolExecutor(max_workers=CONNECTIONS) as executor:
    future_to_url = (executor.submit(load_url, url, TIMEOUT) for url in urls)
    time1 = time.time()
    for future in concurrent.futures.as_completed(future_to_url):
        try:
            data = future.result()
        except Exception as exc:
            data = str(type(exc))
        finally:
            out.append(data)

            print(str(len(out)),end="\r")

    time2 = time.time()

print(f'Took {time2-time1:.2f} s')
print(pd.Series(out).value_counts())

スレッドはここでの答えではありません。それらは、プロセスとカーネルの両方のボトルネックを提供するだけでなく、全体的な目標が「最速の方法」である場合は許容できないスループットの制限を提供します。

少しtwistedとその非同期HTTPクライアントははるかに良い結果を与えるでしょう。

これは古い質問ですが、Python 3.7ではasyncioand を使用してこれを行うことができますaiohttp。

import asyncio
import aiohttp
from aiohttp import ClientSession, ClientConnectorError

async def fetch_html(url: str, session: ClientSession, **kwargs) -> tuple:
    try:
        resp = await session.request(method="GET", url=url, **kwargs)
    except ClientConnectorError:
        return (url, 404)
    return (url, resp.status)

async def make_requests(urls: set, **kwargs) -> None:
    async with ClientSession() as session:
        tasks = []
        for url in urls:
            tasks.append(
                fetch_html(url=url, session=session, **kwargs)
            )
        results = await asyncio.gather(*tasks)

    for result in results:
        print(f'{result[1]} - {str(result[0])}')

if __name__ == "__main__":
    import pathlib
    import sys

    assert sys.version_info >= (3, 7), "Script requires Python 3.7+."
    here = pathlib.Path(__file__).parent

    with open(here.joinpath("urls.txt")) as infile:
        urls = set(map(str.strip, infile))

    asyncio.run(make_requests(urls=urls))

詳細については、こちらの例をご覧ください。

grequestsを使用します。これは、リクエストとGeventモジュールの組み合わせです。

GRequestsを使用すると、Geventでリクエストを使用して非同期のHTTPリクエストを簡単に作成できます。

使い方は簡単です：

import grequests

urls = [
   'http://www.heroku.com',
   'http://tablib.org',
   'http://httpbin.org',
   'http://python-requests.org',
   'http://kennethreitz.com'
]

未送信のリクエストのセットを作成します。

>>> rs = (grequests.get(u) for u in urls)

それらをすべて同時に送信します。

>>> grequests.map(rs)
[<Response [200]>, <Response [200]>, <Response [200]>, <Response [200]>, <Response [200]>]

この問題を解決する良い方法は、最初に1つの結果を得るのに必要なコードを記述し、次にスレッド化コードを組み込んでアプリケーションを並列化することです。

完璧な世界では、これは単に100,000スレッドを同時に開始して、結果を後の処理のためにディクショナリまたはリストに出力することを意味しますが、実際には、この方法で発行できる並列HTTP要求の数に制限があります。ローカルでは、同時に開くことができるソケットの数、Pythonインタープリターが許可する実行のスレッドの数に制限があります。リモートでは、すべてのリクエストが1つのサーバーに対するものである場合、または多数のサーバーに対するものである場合、同時接続数が制限される可能性があります。これらの制限により、一度にURLのごく一部のみをポーリングするような方法でスクリプトを作成することがおそらく必要になります（別の投稿者が述べたように、100はおそらくまともなスレッドプールサイズですが、より多くを正常に展開できます）。

この設計パターンに従って、上記の問題を解決できます。

1. 現在実行中のスレッドの数（threading.active_count（）またはスレッドオブジェクトをデータ構造にプッシュすることで追跡できます）が> =同時リクエストの最大数（たとえば100）になるまで、新しいリクエストスレッドを起動するスレッドを開始します。 、その後、短いタイムアウトの間スリープします。このスレッドは、処理するURLがなくなると終了します。したがって、スレッドは起動し続け、新しいスレッドを起動し、終了するまでスリープします。
2. 要求スレッドに結果を何らかのデータ構造に保存して、後で取得して出力できるようにします。結果を保存する構造がlistまたはdictCPythonの場合、ロックなしでスレッドから一意のアイテムを安全に追加または挿入できますが、ファイルに書き込む場合、またはより複雑なスレッド間データの相互作用が必要な場合は、この状態を破損から保護するための相互排他ロック。

スレッディングモジュールを使用することをお勧めします。これを使用して、実行中のスレッドを起動および追跡できます。Pythonのスレッディングサポートは完全なものではありませんが、問題の説明から、ニーズに対して完全に十分であることがわかります。

最後に、Pythonで作成された並列ネットワークアプリケーションの非常に単純なアプリケーションを見たい場合は、ssh.pyをチェックしてください。これは、Pythonスレッドを使用して多くのSSH接続を並列化する小さなライブラリです。設計は、それが優れたリソースであることがわかるかもしれない要件に十分に近いです。

可能な限り最高のパフォーマンスを得たい場合は、スレッドではなく非同期I / Oの使用を検討してください。数千のOSスレッドに関連するオーバーヘッドは重要なものであり、Pythonインタープリター内でのコンテキストの切り替えにより、さらに多くのものが追加されます。スレッド化は確かに仕事を成し遂げますが、非同期ルートが全体的なパフォーマンスを向上させると私は思っています。

具体的には、Twistedライブラリ（http://www.twistedmatrix.com）の非同期Webクライアントをお勧めします。学習曲線は確かに急ですが、Twistedの非同期プログラミングスタイルをうまく理解すれば、とても簡単に使用できます。

Twistedの非同期WebクライアントAPIのハウツーは、次の場所にあります。

http://twistedmatrix.com/documents/current/web/howto/client.html

解決策：

from twisted.internet import reactor, threads
from urlparse import urlparse
import httplib
import itertools


concurrent = 200
finished=itertools.count(1)
reactor.suggestThreadPoolSize(concurrent)

def getStatus(ourl):
    url = urlparse(ourl)
    conn = httplib.HTTPConnection(url.netloc)   
    conn.request("HEAD", url.path)
    res = conn.getresponse()
    return res.status

def processResponse(response,url):
    print response, url
    processedOne()

def processError(error,url):
    print "error", url#, error
    processedOne()

def processedOne():
    if finished.next()==added:
        reactor.stop()

def addTask(url):
    req = threads.deferToThread(getStatus, url)
    req.addCallback(processResponse, url)
    req.addErrback(processError, url)   

added=0
for url in open('urllist.txt'):
    added+=1
    addTask(url.strip())

try:
    reactor.run()
except KeyboardInterrupt:
    reactor.stop()

テスト時間：

[kalmi@ubi1:~] wc -l urllist.txt
10000 urllist.txt
[kalmi@ubi1:~] time python f.py > /dev/null 

real    1m10.682s
user    0m16.020s
sys 0m10.330s
[kalmi@ubi1:~] head -n 6 urllist.txt
http://www.google.com
http://www.bix.hu
http://www.godaddy.com
http://www.google.com
http://www.bix.hu
http://www.godaddy.com
[kalmi@ubi1:~] python f.py | head -n 6
200 http://www.bix.hu
200 http://www.bix.hu
200 http://www.bix.hu
200 http://www.bix.hu
200 http://www.bix.hu
200 http://www.bix.hu

Pingtime：

bix.hu is ~10 ms away from me
godaddy.com: ~170 ms
google.com: ~30 ms

スレッドプールを使用することは良いオプションであり、これはかなり簡単になります。残念ながら、Pythonにはスレッドプールを非常に簡単にする標準ライブラリがありません。しかし、これはあなたが始めるべききちんとしたライブラリです：http : //www.chrisarndt.de/projects/threadpool/

彼らのサイトからのコード例：

pool = ThreadPool(poolsize)
requests = makeRequests(some_callable, list_of_args, callback)
[pool.putRequest(req) for req in requests]
pool.wait()

お役に立てれば。

epollオブジェクトを作成し、
多くのクライアントTCPソケットを開き
、送信バッファーを要求ヘッダーよりも少し大きくなるように調整し、要求ヘッダーを
送信します—バッファーに配置するだけで、epollオブジェクトにソケットを登録し、オブジェクトに
実行.pollしepoll、
最初に読み取ります3バイトから各ソケットから.poll、
にそれらを書くsys.stdoutに続いて\n（フラッシュません）、近いクライアントソケット。

同時に開くソケットの数を制限します—ソケットの作成時にエラーを処理します。別のソケットが閉じている場合にのみ、新しいソケットを作成します。
OSの制限を調整します。
少数の（多くはない）プロセスに分岐してみてください。これは、CPUを少し効果的に使用するのに役立ちます。

あなたのケースでは、おそらく応答を待つのにほとんどの時間を費やしているので、スレッド化はおそらくうまくいくでしょう。標準ライブラリには、役立つようなQueueのような便利なモジュールがあります。

以前にファイルの並列ダウンロードで同様のことを行いましたが、それで十分でしたが、あなたが話している規模ではありませんでした。

タスクがより多くのCPUにバインドされている場合は、マルチプロセッシングモジュールを確認すると、より多くのCPU /コア/スレッドを使用できるようになります（ロックはプロセスごとに行われるため、お互いをブロックしないより多くのプロセス）。

Windmillの使用を検討してください。ただし、Windmillは、それほど多くのスレッドを実行することはできません。

5台のマシンで手動でローリングしたPythonスクリプトを使用して、それぞれがポート40000から60000を使用してアウトバウンドに接続し、100,000のポート接続を開くことができます。

また、 各サーバーが処理できる量を把握するために、OpenSTAなどの適切にスレッド化されたQAアプリでサンプルテストを行うと役立つ場合があります。

また、LWP :: ConnCacheクラスで単純なPerlを使用することも検討してください。そうすれば、おそらくより多くのパフォーマンス（より多くの接続）が得られます。

このねじれた非同期Webクライアントは、かなり高速になります。

#!/usr/bin/python2.7

from twisted.internet import reactor
from twisted.internet.defer import Deferred, DeferredList, DeferredLock
from twisted.internet.defer import inlineCallbacks
from twisted.web.client import Agent, HTTPConnectionPool
from twisted.web.http_headers import Headers
from pprint import pprint
from collections import defaultdict
from urlparse import urlparse
from random import randrange
import fileinput

pool = HTTPConnectionPool(reactor)
pool.maxPersistentPerHost = 16
agent = Agent(reactor, pool)
locks = defaultdict(DeferredLock)
codes = {}

def getLock(url, simultaneous = 1):
    return locks[urlparse(url).netloc, randrange(simultaneous)]

@inlineCallbacks
def getMapping(url):
    # Limit ourselves to 4 simultaneous connections per host
    # Tweak this number, but it should be no larger than pool.maxPersistentPerHost 
    lock = getLock(url,4)
    yield lock.acquire()
    try:
        resp = yield agent.request('HEAD', url)
        codes[url] = resp.code
    except Exception as e:
        codes[url] = str(e)
    finally:
        lock.release()


dl = DeferredList(getMapping(url.strip()) for url in fileinput.input())
dl.addCallback(lambda _: reactor.stop())

reactor.run()
pprint(codes)

tornadoこれを実現するには、パッケージを使用するのが最も速くて簡単な方法であることがわかりました。

from tornado import ioloop, httpclient, gen


def main(urls):
    """
    Asynchronously download the HTML contents of a list of URLs.
    :param urls: A list of URLs to download.
    :return: List of response objects, one for each URL.
    """

    @gen.coroutine
    def fetch_and_handle():
        httpclient.AsyncHTTPClient.configure(None, defaults=dict(user_agent='MyUserAgent'))
        http_client = httpclient.AsyncHTTPClient()
        waiter = gen.WaitIterator(*[http_client.fetch(url, raise_error=False, method='HEAD')
                                    for url in urls])
        results = []
        # Wait for the jobs to complete
        while not waiter.done():
            try:
                response = yield waiter.next()
            except httpclient.HTTPError as e:
                print(f'Non-200 HTTP response returned: {e}')
                continue
            except Exception as e:
                print(f'An unexpected error occurred querying: {e}')
                continue
            else:
                print(f'URL \'{response.request.url}\' has status code <{response.code}>')
                results.append(response)
        return results

    loop = ioloop.IOLoop.current()
    web_pages = loop.run_sync(fetch_and_handle)

    return web_pages

my_urls = ['url1.com', 'url2.com', 'url100000.com']
responses = main(my_urls)
print(responses[0])

最も簡単な方法は、Pythonの組み込みスレッドライブラリを使用することです。それらは「実際の」/カーネルスレッドではありません（シリアル化などの）問題がありますが、十分です。キューとスレッドプールが必要です。ここに1つのオプションがありますが、独自に作成するのは簡単です。100,000件の呼び出しをすべて並列化することはできませんが、同時に100件程度の呼び出しを実行できます。