Greenlet vs. Thread

Question

Sono nuovo di gevents e greenlets. Ho trovato una buona documentazione su come lavorare con loro, ma nessuno mi ha dato una giustificazione su come e quando dovrei usare i greenlets!

• In cosa sono veramente bravi?
• È consigliabile utilizzarli in un server proxy oppure no?
• Perché non thread?

Quello di cui non sono sicuro è come possano fornirci la concorrenza se sono fondamentalmente co-routines.

Answer 1

Greenlets forniscono simultanea ma non parallelismo. La concorrenza è quando il codice può essere eseguito indipendentemente da un altro codice. Parallelismo è l'esecuzione simultanea di codice simultaneo. Il parallelismo è particolarmente utile quando c'è molto lavoro da fare nello userspace, e di solito è roba da CPU. La concorrenza è utile per rompere i problemi, consentendo di pianificare e gestire più parti in parallelo più facilmente.

I greenlet brillano davvero nella programmazione di rete in cui le interazioni con un socket possono verificarsi indipendentemente dalle interazioni con altri socket. Questo è un classico esempio di concorrenza. Poiché ogni greenlet viene eseguita nel proprio contesto, è possibile continuare a utilizzare le API sincrone senza eseguire il threading. Ciò è positivo perché i thread sono molto costosi in termini di memoria virtuale e overhead del kernel, quindi la concorrenza che è possibile ottenere con i thread è significativamente inferiore. Inoltre, il threading in Python è più costoso e più limitato del solito a causa della GIL. Le alternative alla concorrenza sono in genere progetti come Twisted, libevent, libuv, node.js ecc., In cui tutto il codice condivide lo stesso contesto di esecuzione e registra i gestori di eventi.

È un'ottima idea utilizzare i greenlet (con supporto di rete appropriato come tramite gevent) per scrivere un proxy, poiché la gestione delle richieste è in grado di eseguirsi in modo indipendente e deve essere scritta come tale.

I greenlet forniscono la concorrenza per i motivi che ho dato in precedenza. La concorrenza non è il parallelismo. Nascondendo la registrazione degli eventi e eseguendo la pianificazione per le chiamate che normalmente bloccheranno il thread corrente, i progetti come gevent espongono questa concorrenza senza richiedere modifiche a un'API asincrona e a costi significativamente inferiori per il sistema.

• Concurrency is not parallelism
• Threads vs. processes
• Multiprocessing vs. threads
• GIL vs. CPython

Answer 2

Questo è abbastanza interessante da analizzare. Ecco un codice per confrontare le prestazioni di greenlets rispetto multiprocessing piscina contro il 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() 

ecco i risultati:

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

Credo che greenlet sostiene che non è vincolato da GIL a differenza la libreria multithreading. Inoltre, il dott. Greenlet dice che è pensato per le operazioni di rete. Per un'operazione intensiva di rete, il cambio di thread va bene e puoi vedere che l'approccio al multithreading è piuttosto veloce. Inoltre è sempre preferibile usare le librerie ufficiali di python; Ho provato a installare greenlet su Windows e ho riscontrato un problema di dipendenza da dll, quindi ho eseguito questo test su un Linux vm. Provare sempre a scrivere un codice con la speranza che funzioni su qualsiasi macchina.

Answer 3

Prendendo la risposta di @ Max e aggiungendo qualche rilevanza per il ridimensionamento, è possibile vedere la differenza. Ho raggiunto questo cambiando gli URL da riempire come segue:

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) 

ho dovuto abbandonare la versione multiprocesso che cadeva prima avevo 500; ma a 10.000 iterazioni:

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

Così si può vedere c'è qualche differenza significativa nel I/O utilizzando gevent