Greenlet Vs. Utas

Saya baru mengenal gevents dan greenlets. Saya menemukan beberapa dokumentasi yang bagus tentang cara bekerja dengan mereka, tetapi tidak ada yang memberi saya pembenaran tentang bagaimana dan kapan saya harus menggunakan greenlets!

• Apa yang benar-benar mereka kuasai?
• Apakah ide yang baik untuk menggunakannya di server proxy atau tidak?
• Kenapa tidak utas?

Apa yang saya tidak yakin tentang bagaimana mereka bisa memberikan kita konkurensi jika mereka pada dasarnya adalah co-rutinitas.

Greenlets memberikan konkurensi tetapi tidak paralelisme. Concurrency adalah ketika kode dapat berjalan secara independen dari kode lain. Paralelisme adalah eksekusi kode konkuren secara bersamaan. Paralelisme sangat berguna ketika ada banyak pekerjaan yang harus dilakukan di userspace, dan itu biasanya hal-hal yang berat CPU. Concurrency berguna untuk memecahkan masalah, memungkinkan berbagai bagian dijadwalkan dan dikelola lebih mudah secara paralel.

Greenlets benar-benar bersinar dalam pemrograman jaringan di mana interaksi dengan satu soket dapat terjadi secara terpisah dari interaksi dengan soket lainnya. Ini adalah contoh klasik konkurensi. Karena setiap greenlet berjalan dalam konteksnya sendiri, Anda dapat terus menggunakan API sinkron tanpa threading. Ini bagus karena utas sangat mahal dalam hal memori virtual dan overhead kernel, sehingga konkurensi yang dapat Anda lakukan dengan utas jauh lebih sedikit. Selain itu, threading dengan Python lebih mahal dan lebih terbatas dari biasanya karena GIL. Alternatif untuk konkurensi biasanya proyek-proyek seperti Twisted, libevent, libuv, node.js dll, di mana semua kode Anda berbagi konteks eksekusi yang sama, dan mendaftarkan penangan acara.

Merupakan ide yang bagus untuk menggunakan greenlets (dengan dukungan jaringan yang sesuai seperti melalui gevent) untuk menulis proxy, karena penanganan permintaan Anda dapat dieksekusi secara independen dan harus ditulis seperti itu.

Greenlets memberikan konkurensi untuk alasan yang saya berikan sebelumnya. Konkurensi bukanlah paralelisme. Dengan menyembunyikan registrasi acara dan melakukan penjadwalan untuk Anda pada panggilan yang biasanya akan memblokir utas saat ini, proyek-proyek seperti gevent mengungkapkan konkurensi ini tanpa memerlukan perubahan ke API asinkron, dan dengan biaya yang jauh lebih murah untuk sistem Anda.

• Konkurensi bukanlah paralelisme
• Thread vs proses
• Multiprocessing vs. utas
• GIL vs CPython

Mengambil jawaban @ Max dan menambahkan beberapa relevansi untuk penskalaan, Anda dapat melihat perbedaannya. Saya mencapai ini dengan mengubah URL yang akan diisi sebagai berikut:

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)

Saya harus keluar versi multiproses karena jatuh sebelum saya punya 500; tetapi pada 10.000 iterasi:

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

Jadi Anda bisa melihat ada beberapa perbedaan yang signifikan dalam I / O menggunakan gevent

Mengoreksi jawaban @TemporalBeing di atas, greenlets tidak "lebih cepat" dari utas dan itu adalah teknik pemrograman yang salah untuk menelurkan 60000 utas untuk memecahkan masalah konkurensi, sekelompok kecil utas bukannya sesuai. Berikut ini adalah perbandingan yang lebih masuk akal (dari posting reddit saya dalam menanggapi orang-orang yang mengutip posting SO ini).

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)

Berikut ini beberapa hasilnya:

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

kesalahpahaman yang dimiliki setiap orang tentang non-pemblokiran IO dengan Python adalah keyakinan bahwa juru bahasa Python dapat menangani pekerjaan mengambil hasil dari soket pada skala besar lebih cepat daripada koneksi jaringan itu sendiri dapat mengembalikan IO. Walaupun ini memang benar dalam beberapa kasus, itu tidak benar hampir sesering yang dipikirkan orang, karena interpreter Python benar-benar lambat. Dalam posting blog saya di sini , saya mengilustrasikan beberapa profil grafis yang menunjukkan bahwa untuk hal-hal yang sangat sederhana sekalipun, jika Anda berurusan dengan akses jaringan yang tajam dan cepat ke hal-hal seperti database atau server DNS, layanan tersebut dapat kembali jauh lebih cepat daripada kode Python dapat menangani ribuan koneksi tersebut.

Ini cukup menarik untuk dianalisis. Berikut ini adalah kode untuk membandingkan kinerja greenlets versus kumpulan multi-pemrosesan 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()

berikut hasilnya:

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

Saya pikir Greenlet mengklaim bahwa itu tidak terikat oleh GIL tidak seperti perpustakaan multithreading. Selain itu, Greenlet doc mengatakan bahwa ini dimaksudkan untuk operasi jaringan. Untuk operasi jaringan yang intensif, penggantian ulir baik-baik saja dan Anda dapat melihat bahwa pendekatan multithreading cukup cepat. Juga selalu disukai menggunakan perpustakaan resmi python; Saya mencoba menginstal greenlet di windows dan mengalami masalah ketergantungan dll jadi saya menjalankan tes ini pada vm linux. Alway mencoba menulis kode dengan harapan dapat berjalan pada mesin apa pun.