Jaki jest najlepszy sposób wysyłania wielu żądań HTTP w Pythonie 3?

Question

Pomysł jest prosty: muszę wysyłać wiele żądań HTTP równolegle.

Zdecydowałem się użyć do tego biblioteki requests-futures, która zasadniczo odradza wiele wątków.

Teraz mam około 200 żądań i wciąż jest dość powolny (zajmuje około 12 sekund na moim laptopie). Używam również wywołania zwrotnego, aby przeanalizować odpowiedź json (zgodnie z sugestią zawartą w dokumentacji biblioteki). Czy istnieje pewna reguła pozwalająca ustalić optymalną liczbę wątków w zależności od liczby żądań, czy istnieje?

W zasadzie zastanawiałem się, czy mogę przyspieszyć te prośby.

Answer 1

Ponieważ używasz Pythona 3.3, polecam rozwiązanie stdlib, którego nie znajdziesz w połączonym wątku przez @ njzk2: concurrent.futures.

To jest wyższy poziom niż tylko prymitywów threading lub multiprocessing. Otrzymasz interfejs Executor do obsługi pulowania i raportowania asynchronicznego.

Docs mają przykład, który jest w zasadzie bezpośrednie zastosowanie do sytuacji, więc ja po prostu upuścić go tutaj:

import concurrent.futures 
import urllib.request 

URLS = #[some list of urls] 

# Retrieve a single page and report the url and contents 
def load_url(url, timeout): 
    conn = urllib.request.urlopen(url, timeout=timeout) 
    return conn.readall() 

# We can use a with statement to ensure threads are cleaned up promptly 
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor: 
    # Start the load operations and mark each future with its URL 
    future_to_url = {executor.submit(load_url, url, 60): url for url in URLS} 
    for future in concurrent.futures.as_completed(future_to_url): 
     url = future_to_url[future] 
     try: 
      data = future.result() 
      # do json processing here 
     except Exception as exc: 
      print('%r generated an exception: %s' % (url, exc)) 
     else: 
      print('%r page is %d bytes' % (url, len(data))) 

Można zastąpić urllib.request połączeń z requests połączeń, jeśli sobie tego życzą. Z oczywistych powodów mam tendencję do podobania się bardziej.

Interfejs API wygląda trochę tak: zrób kilka obiektów reprezentujących asynchroniczne wykonywanie funkcji. Następnie należy użyć concurrent.futures.as_completed, aby podać iterator dla instancji Future. Opuści je, gdy zostaną ukończone.

Co do twojego pytania:

Ponadto, istnieje zasada, aby dowiedzieć się optymalną liczbę wątków w zależności od liczby wniosków, czy istnieje?

Zasada kciuka, nie. To zależy od zbyt wielu rzeczy, w tym szybkości połączenia internetowego. Powiem, że to naprawdę nie zależy od liczby otrzymanych żądań, więcej od sprzętu, który używasz.

Na szczęście dość łatwo jest poprawić koder max_workers i przetestować samodzielnie. Rozpocznij od 5 lub 10 wątków, zwiększaj przyrosty o 5. Prawdopodobnie zauważysz w pewnym momencie obniżenie wydajności, a następnie zaczniesz zmniejszać, ponieważ dodatkowy narzut dodawania dodatkowych nici przewyższa marginalne wzmocnienie zwiększonej równoległości (co jest słowem) .