Greenlet vs. Tópicos

Eu sou novo em gevents e greenlets. Encontrei uma boa documentação sobre como trabalhar com eles, mas nenhuma me deu justificativa sobre como e quando devo usar os greenlets!

• No que eles são realmente bons?
• É uma boa ideia usá-los em um servidor proxy ou não?
• Por que não tópicos?

O que não tenho certeza é como eles podem nos fornecer simultaneidade se forem basicamente co-rotinas.

Os greenlets fornecem simultaneidade, mas não paralelismo. Simultaneidade é quando o código pode ser executado independentemente de outro código. Paralelismo é a execução de código simultâneo simultaneamente. O paralelismo é particularmente útil quando há muito trabalho a ser feito no espaço do usuário, e isso geralmente envolve coisas pesadas na CPU. A simultaneidade é útil para desmembrar problemas, permitindo que diferentes partes sejam agendadas e gerenciadas mais facilmente em paralelo.

Os greenlets realmente brilham na programação de rede em que as interações com um soquete podem ocorrer independentemente das interações com outros soquetes. Este é um exemplo clássico de simultaneidade. Como cada greenlet é executado em seu próprio contexto, você pode continuar usando APIs síncronas sem segmentação. Isso é bom porque os threads são muito caros em termos de memória virtual e sobrecarga do kernel; portanto, a simultaneidade que você pode obter com os threads é significativamente menor. Além disso, a segmentação em Python é mais cara e mais limitada do que o normal devido ao GIL. Alternativas à simultaneidade são geralmente projetos como Twisted, libevent, libuv, node.js etc., em que todo o seu código compartilha o mesmo contexto de execução e registra manipuladores de eventos.

É uma excelente ideia usar greenlets (com suporte de rede apropriado, como por meio de gevent) para escrever um proxy, pois o processamento de solicitações é capaz de executar independentemente e deve ser escrito como tal.

Os greenlets proporcionam simultaneidade pelas razões que mencionei anteriormente. Concorrência não é paralelismo. Ao ocultar o registro de eventos e executar o agendamento para você em chamadas que normalmente bloqueariam o encadeamento atual, projetos como gevent expõem essa simultaneidade sem exigir a alteração de uma API assíncrona e a um custo significativamente menor para o seu sistema.

• Concorrência não é paralelismo
• Threads vs. processos
• Multiprocessamento vs. threads
• GIL vs. CPython

Tomando a resposta do @ Max e adicionando alguma relevância para o dimensionamento, você pode ver a diferença. Consegui isso alterando os URLs a serem preenchidos da seguinte maneira:

URLS_base = ['www.google.com', 'www.example.com', 'www.python.org', 'www.yahoo.com', 'www.ubc.ca', 'www.wikipedia.org']
URLS = []
for _ in range(10000):
    for url in URLS_base:
        URLS.append(url)

Eu tive que abandonar a versão multiprocesso, pois ela caía antes dos 500; mas em 10.000 iterações:

Using gevent it took: 3.756914
-----------
Using multi-threading it took: 15.797028

Então você pode ver que há alguma diferença significativa na E / S usando o gevent

Corrigindo a resposta do @TemporalBeing acima, os greenlets não são "mais rápidos" que os threads e é uma técnica de programação incorreta gerar 60000 threads para resolver um problema de simultaneidade, um pequeno conjunto de threads é apropriado. Aqui está uma comparação mais razoável (do meu post no reddit em resposta a pessoas que citam este post no SO).

import gevent
from gevent import socket as gsock
import socket as sock
import threading
from datetime import datetime


def timeit(fn, URLS):
    t1 = datetime.now()
    fn()
    t2 = datetime.now()
    print(
        "%s / %d hostnames, %s seconds" % (
            fn.__name__,
            len(URLS),
            (t2 - t1).total_seconds()
        )
    )


def run_gevent_without_a_timeout():
    ip_numbers = []

    def greenlet(domain_name):
        ip_numbers.append(gsock.gethostbyname(domain_name))

    jobs = [gevent.spawn(greenlet, domain_name) for domain_name in URLS]
    gevent.joinall(jobs)
    assert len(ip_numbers) == len(URLS)


def run_threads_correctly():
    ip_numbers = []

    def process():
        while queue:
            try:
                domain_name = queue.pop()
            except IndexError:
                pass
            else:
                ip_numbers.append(sock.gethostbyname(domain_name))

    threads = [threading.Thread(target=process) for i in range(50)]

    queue = list(URLS)
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    assert len(ip_numbers) == len(URLS)

URLS_base = ['www.google.com', 'www.example.com', 'www.python.org',
             'www.yahoo.com', 'www.ubc.ca', 'www.wikipedia.org']

for NUM in (5, 50, 500, 5000, 10000):
    URLS = []

    for _ in range(NUM):
        for url in URLS_base:
            URLS.append(url)

    print("--------------------")
    timeit(run_gevent_without_a_timeout, URLS)
    timeit(run_threads_correctly, URLS)

Aqui estão alguns resultados:

--------------------
run_gevent_without_a_timeout / 30 hostnames, 0.044888 seconds
run_threads_correctly / 30 hostnames, 0.019389 seconds
--------------------
run_gevent_without_a_timeout / 300 hostnames, 0.186045 seconds
run_threads_correctly / 300 hostnames, 0.153808 seconds
--------------------
run_gevent_without_a_timeout / 3000 hostnames, 1.834089 seconds
run_threads_correctly / 3000 hostnames, 1.569523 seconds
--------------------
run_gevent_without_a_timeout / 30000 hostnames, 19.030259 seconds
run_threads_correctly / 30000 hostnames, 15.163603 seconds
--------------------
run_gevent_without_a_timeout / 60000 hostnames, 35.770358 seconds
run_threads_correctly / 60000 hostnames, 29.864083 seconds

o mal-entendido que todos têm sobre E / S não bloqueadoras com Python é a crença de que o intérprete Python pode prestar atenção ao trabalho de recuperar resultados de soquetes em larga escala mais rapidamente do que as próprias conexões de rede podem devolver E / S. Embora isso certamente seja verdade em alguns casos, não é quase tão freqüentemente quanto as pessoas pensam, porque o intérprete Python é muito, muito lento. No meu blog aqui , ilustro alguns perfis gráficos que mostram que, mesmo para coisas muito simples, se você estiver lidando com acesso rápido e nítido à rede a coisas como bancos de dados ou servidores DNS, esses serviços poderão retornar muito mais rapidamente que o código Python pode atender a muitos milhares dessas conexões.

Isso é interessante o suficiente para analisar. Aqui está um código para comparar o desempenho de greenlets versus pool de multiprocessamento versus multi-threading:

import gevent
from gevent import socket as gsock
import socket as sock
from multiprocessing import Pool
from threading import Thread
from datetime import datetime

class IpGetter(Thread):
    def __init__(self, domain):
        Thread.__init__(self)
        self.domain = domain
    def run(self):
        self.ip = sock.gethostbyname(self.domain)

if __name__ == "__main__":
    URLS = ['www.google.com', 'www.example.com', 'www.python.org', 'www.yahoo.com', 'www.ubc.ca', 'www.wikipedia.org']
    t1 = datetime.now()
    jobs = [gevent.spawn(gsock.gethostbyname, url) for url in URLS]
    gevent.joinall(jobs, timeout=2)
    t2 = datetime.now()
    print "Using gevent it took: %s" % (t2-t1).total_seconds()
    print "-----------"
    t1 = datetime.now()
    pool = Pool(len(URLS))
    results = pool.map(sock.gethostbyname, URLS)
    t2 = datetime.now()
    pool.close()
    print "Using multiprocessing it took: %s" % (t2-t1).total_seconds()
    print "-----------"
    t1 = datetime.now()
    threads = []
    for url in URLS:
        t = IpGetter(url)
        t.start()
        threads.append(t)
    for t in threads:
        t.join()
    t2 = datetime.now()
    print "Using multi-threading it took: %s" % (t2-t1).total_seconds()

aqui estão os resultados:

Using gevent it took: 0.083758
-----------
Using multiprocessing it took: 0.023633
-----------
Using multi-threading it took: 0.008327

Penso que o greenlet alega que não está vinculado pelo GIL, ao contrário da biblioteca multithreading. Além disso, o documento Greenlet diz que se destina a operações de rede. Para uma operação intensiva em rede, a troca de threads é boa e você pode ver que a abordagem de multithreading é bastante rápida. Também é sempre preferível usar as bibliotecas oficiais do python; Eu tentei instalar o greenlet no windows e encontrou um problema de dependência da dll, então eu executei este teste em um linux vm. Sempre tente escrever um código com a esperança de que seja executado em qualquer máquina.