ग्रीनलेट बनाम। थ्रेड

Question

मैं gevents और greenlets के लिए नया हूँ। मुझे उनके साथ काम करने के तरीके पर कुछ अच्छा प्रलेखन मिला, लेकिन किसी ने मुझे औपचारिकता नहीं दी कि मुझे कब और कब ग्रीनलेट का उपयोग करना चाहिए!

• वे वास्तव में क्या अच्छे हैं?
• क्या यह प्रॉक्सी सर्वर में उपयोग करना अच्छा नहीं है या नहीं?
• धागे क्यों नहीं?

मुझे इस बारे में निश्चित नहीं है कि वे मूल रूप से सह-रूटीन होने पर हमें समवर्तीता प्रदान कर सकते हैं।

Answer 1

ग्रीनलेट समेकन प्रदान करते हैं लेकिन समांतरता प्रदान नहीं करते हैं। Concurrency तब होता है जब कोड अन्य कोड से स्वतंत्र रूप से चलाया जा सकता है। समांतरता एक साथ समवर्ती कोड का निष्पादन है। समांतरता विशेष रूप से उपयोगी होती है जब उपयोगकर्तास्थान में बहुत सारे काम किए जाते हैं, और यह आमतौर पर सीपीयू-भारी सामान होता है। Concurrency अलग-अलग समस्याओं को तोड़ने के लिए उपयोगी है, जिससे विभिन्न हिस्सों को निर्धारित किया जा सकता है और समानांतर में अधिक आसानी से प्रबंधित किया जा सकता है।

ग्रीनलेट वास्तव में नेटवर्क प्रोग्रामिंग में चमकते हैं जहां एक सॉकेट के साथ बातचीत अन्य सॉकेट के साथ बातचीत के स्वतंत्र रूप से हो सकती है। यह समवर्तीता का एक उत्कृष्ट उदाहरण है। चूंकि प्रत्येक ग्रीनलेट अपने संदर्भ में चलता है, इसलिए आप थ्रेडिंग के बिना सिंक्रोनस एपीआई का उपयोग करना जारी रख सकते हैं। यह अच्छा है क्योंकि वर्चुअल मेमोरी और कर्नेल ओवरहेड के मामले में धागे बहुत महंगा हैं, इसलिए थ्रेड के साथ प्राप्त समेकन काफी कम है। इसके अतिरिक्त, पाइथन में थ्रेडिंग अधिक महंगा है और जीआईएल के कारण सामान्य से अधिक सीमित है। समेकन के विकल्प आमतौर पर ट्विस्ट, libevent, libuv, node.js आदि जैसी परियोजनाएं होती हैं, जहां आपका सभी कोड समान निष्पादन संदर्भ साझा करता है, और ईवेंट हैंडलर पंजीकृत करता है।

प्रॉक्सी लिखने के लिए ग्रीनलेट्स (उचित नेटवर्किंग समर्थन जैसे भूगर्भ के माध्यम से) का उपयोग करना एक उत्कृष्ट विचार है, क्योंकि अनुरोधों का प्रबंधन स्वतंत्र रूप से निष्पादित करने में सक्षम है और इसे इस तरह लिखा जाना चाहिए।

ग्रीनलेट पहले दिए गए कारणों के लिए सहमति प्रदान करते हैं। Concurrency समानांतरता नहीं है। इवेंट पंजीकरण छुपाकर और उन कॉलों पर आपके लिए समय-सारिणी निष्पादित करके जो सामान्य थ्रेड को अवरुद्ध करेंगे, गीवेन्ट जैसी परियोजनाएं इस समेकन को एक एसिंक्रोनस एपीआई में बदलने की आवश्यकता के बिना, और आपके सिस्टम पर काफी कम लागत के बिना प्रकट करती हैं।

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

Answer 2

यह काफी दिलचस्प विश्लेषण करने के लिए है। यहाँ बनाम बहु सूत्रण पूल बहु बनाम greenlets के प्रदर्शन की तुलना करने के लिए एक कोड है:

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

मुझे लगता है कि greenlet का दावा है कि यह है कि यह विपरीत Gil द्वारा बाध्य नहीं है:

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

यहाँ

परिणाम हैं multithreading पुस्तकालय। इसके अलावा, ग्रीनलेट डॉक्टर का कहना है कि यह नेटवर्क संचालन के लिए है। नेटवर्क गहन ऑपरेशन के लिए, थ्रेड-स्विचिंग ठीक है और आप देख सकते हैं कि मल्टीथ्रेडिंग दृष्टिकोण बहुत तेज़ है। यह भी हमेशा पाइथन के आधिकारिक पुस्तकालयों का उपयोग करने के लिए prefeerable है; मैंने विंडोज़ पर ग्रीनलेट स्थापित करने की कोशिश की और एक डीएल निर्भरता समस्या का सामना किया, इसलिए मैंने इस परीक्षण को लिनक्स वीएम पर चलाया। हमेशा किसी भी मशीन पर चलने वाली उम्मीद के साथ एक कोड लिखने का प्रयास करें।

Answer 3

मैक्स के उत्तर को लेना और स्केलिंग के लिए इसमें कुछ प्रासंगिकता जोड़ना, आप अंतर देख सकते हैं। मैं इस प्रकार भरे जाने वाले URL को बदलने कर यह उपलब्धि हासिल:

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 था मल्टीप्रोसेस संस्करण बाहर छोड़ना पड़ा; लेकिन 10,000 पुनरावृत्तियों में:

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

तो आप देख सकते वहाँ gevent