Greenlet Vs. İş Parçacığı

Gents ve yeşiller için yeniyim. Onlarla nasıl çalışacağım hakkında bazı iyi belgeler buldum, ancak hiçbiri bana broşürleri nasıl ve ne zaman kullanmam gerektiği konusunda gerekçe göstermedi!

• Gerçekten neyi iyi yapıyorlar?
• Bunları proxy sunucusunda kullanmak iyi bir fikir mi?
• Neden iplikler değil?

Emin olmadığım şey, temelde ortak rutinler ise bize nasıl eşzamanlılık sağlayabilecekleri.

Greenlets eşzamanlılık sağlar ancak sağlamaz paralelliği. Eşzamanlılık, kodun diğer kodlardan bağımsız olarak çalıştırılabildiği zamandır. Paralellik eşzamanlı kodun eşzamanlı olarak yürütülmesidir. Paralellik özellikle kullanıcı alanında yapılması gereken çok iş olduğunda kullanışlıdır ve bu genellikle CPU ağırlıklı şeylerdir. Eşzamanlılık, farklı parçaların paralel olarak daha kolay planlanmasına ve yönetilmesine olanak tanıyan sorunları parçalamak için kullanışlıdır.

Greenlets, bir soketle etkileşimlerin diğer soketlerle etkileşimlerden bağımsız olarak gerçekleşebileceği ağ programlamasında gerçekten parlar. Bu eşzamanlılığın klasik bir örneğidir. Her bir greenlet kendi bağlamında çalıştığından, senkronize edilmeden senkronize API'ları kullanmaya devam edebilirsiniz. Bu iyidir çünkü iş parçacıkları sanal bellek ve çekirdek yükü açısından çok pahalıdır, bu nedenle iş parçacıklarıyla elde edebileceğiniz eşzamanlılık önemli ölçüde daha azdır. Buna ek olarak, Python'da diş açma GIL nedeniyle normalden daha pahalı ve daha sınırlıdır. Eşzamanlılığa alternatifler genellikle Twisted, libevent, libuv, node.js vb. Gibi tüm kodlarınızın aynı yürütme içeriğini paylaştığı ve olay işleyicilerini kaydettiği projelerdir.

Taleplerin ele alınabilmesi bağımsız olarak yürütülebildiğinden ve bu şekilde yazılması gerektiğinden, vekil yazmak için broşürleri (gevent gibi uygun ağ desteği ile) kullanmak mükemmel bir fikirdir.

Greenlets, daha önce verdiğim nedenler için eşzamanlılık sağlar. Eşzamanlılık paralellik değildir. Etkinlik kaydını gizleyerek ve normalde mevcut iş parçacığını engelleyecek aramalarda sizin için zamanlama gerçekleştirerek, gevent gibi projeler, eşzamanlı olmayan bir API'da değişiklik gerektirmeden ve sisteminizde önemli ölçüde daha az maliyetle bu eşzamanlılığı ortaya çıkarır.

• Eşzamanlılık paralellik değil
• Konular ve süreçler
• Çoklu işlem ve dişler
• GIL ve CPython Karşılaştırması

@ Max'in cevabını alarak ölçeklendirme için ona bir miktar ilgi ekleyerek farkı görebilirsiniz. Doldurulacak URL'leri aşağıdaki gibi değiştirerek bunu başardım:

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)

500 yaşımdan önce düştüğü için çoklu işlem versiyonunu bırakmak zorunda kaldım; ancak 10.000 yinelemede:

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

Gevent kullanarak G / Ç'de önemli bir fark olduğunu görebilirsiniz.

Yukarıdaki @TemporalBeing yanıtı için düzeltme, greenlets iş parçacıklarından daha hızlı değildir ve bir eşzamanlılık sorununu çözmek için 60000 iş parçacığı oluşturmak yanlış bir programlama tekniğidir , bunun yerine küçük bir iş parçacığı havuzu uygundur. İşte daha makul bir karşılaştırma ( bu SO yazı alıntı insanlar yanıt olarak benim reddit yazı).

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)

İşte bazı sonuçlar:

--------------------
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

herkesin Python ile bloke olmama IO'su hakkındaki yanlış anlaşılma, Python yorumlayıcısının ağ bağlantılarının kendilerinden IO döndüğünden daha hızlı bir şekilde yuvalardan sonuç alma çalışmalarına katılabileceği inancıdır. Bu bazı durumlarda kesinlikle doğru olsa da, insanların düşündüğü kadar doğru değildir, çünkü Python yorumlayıcısı gerçekten, gerçekten yavaştır. Benim içinde buraya blog post , sana gevrek ve veritabanları veya DNS sunucularının gibi şeyler hızlı ağ erişimi ile ilgileniyor eğer, hatta çok basit şeyler için olduğunu göstermektedir bazı grafiksel profillerini göstermektedir, bu hizmetleri daha hızlı Python kodu daha çok geri gelebilir bu bağlantıların binlerceine katılabilir.

Bu analiz için yeterince ilginç. Çok sayıda iş parçacığı ile çok işlemcili havuz ve çok işlemcili havuz arasındaki performansı karşılaştırmak için bir kod:

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()

sonuçlar burada:

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

Greenlet'in çok iş parçacıklı kütüphaneden farklı olarak GIL tarafından bağlı olmadığını iddia ettiğini düşünüyorum. Dahası, Greenlet doc ağ operasyonları için olduğunu söylüyor. Ağ yoğun bir işlem için, iplik geçişi iyidir ve çoklu iş parçacığı yaklaşımının oldukça hızlı olduğunu görebilirsiniz. Ayrıca python'un resmi kütüphanelerini kullanmak her zaman tercih edilir; Ben windows üzerinde greenlet yüklemeyi denedim ve bu yüzden bir linux vm üzerinde bu testi koştu bir dll bağımlılığı sorunu karşılaştı. Alway, herhangi bir makinede çalışması umuduyla bir kod yazmaya çalışın.