2008-08-27 17 views
73

मैं पाइथन में थ्रेड कैसे काम करता हूं, इस बारे में अपने सिर को लपेटने की कोशिश कर रहा हूं, और यह कैसे काम करता है इस बारे में अच्छी जानकारी प्राप्त करना मुश्किल है। मुझे बस एक लिंक या कुछ याद आ रहा है, लेकिन ऐसा लगता है कि आधिकारिक दस्तावेज इस विषय पर बहुत गहन नहीं है, और मैं एक अच्छा लेखन-पत्र नहीं ढूंढ पाया।पाइथन में धागे कैसे काम करते हैं, और सामान्य पायथन-थ्रेडिंग विशिष्ट नुकसान क्या हैं?

जो मैं कह सकता हूं, केवल एक धागा एक ही समय में चल रहा है, और सक्रिय धागा हर 10 निर्देशों को स्विच करता है या नहीं?

कोई अच्छी व्याख्या कहां है, या आप एक प्रदान कर सकते हैं? पाइथन के साथ धागे का उपयोग करते समय आप सामान्य समस्याओं के बारे में जागरूक होना भी बहुत अच्छा होगा।

उत्तर

46

हाँ, वैश्विक दुभाषिया लॉक (जीआईएल) की वजह से वहाँ केवल कर सकते हैं एक समय में एक धागा चलाओ।यहाँ इस बारे में कुछ जानकारी के आधार पर कुछ लिंक कर रहे हैं:

पिछले लिंक से

एक दिलचस्प बोली:

मुझे समझाने क्या सभी इसका मतलब है कि करते हैं। समान वर्चुअल मशीन के अंदर थ्रेड चलते हैं, और इसलिए भौतिक मशीन पर चलते हैं। प्रक्रियाएं उसी भौतिक मशीन पर या में एक और भौतिक मशीन चला सकती हैं। यदि आप थ्रेड के आसपास अपना एप्लिकेशन आर्किटेक्ट करते हैं, तो आपने एकाधिक मशीनों तक पहुंचने के लिए कुछ भी नहीं किया है। इसलिए, आप को स्केल कर सकते हैं क्योंकि कई कोर एकल मशीन पर हैं (जो समय के साथ कुछ होगा), लेकिन वास्तव में वेब स्केल तक पहुंचने के लिए, आपको एकाधिक मशीन समस्या को हल करने की आवश्यकता होगी।

यदि आप बहु कोर का उपयोग करना चाहते हैं, pyprocessing वास्तविक समांतरता करने के लिए प्रक्रिया आधारित API को परिभाषित करता है। PEP में कुछ दिलचस्प मानक भी शामिल हैं।

+1

वास्तव में चिकनीपन उद्धरण पर एक टिप्पणी: निश्चित रूप से पाइथन थ्रेडिंग आपको प्रभावी रूप से एक कोर तक सीमित कर देती है, भले ही मशीन में कई हैं?मल्टीकोर से लाभ हो सकते हैं क्योंकि अगला धागा संदर्भ स्विच के बिना जाने के लिए तैयार हो सकता है, लेकिन आपके पायथन थ्रेड कभी भी 1 कोर का उपयोग कभी नहीं कर सकते हैं। –

+2

सही, पाइथन धागे व्यावहारिक रूप से एक कोर तक ही सीमित हैं, एक सी मॉड्यूल जीआईएल के साथ अच्छी तरह से बातचीत करता है, और इसे अपने मूल धागे चलाता है। – Arafangion

+0

दरअसल, एकाधिक कोर धागे _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ यहां तक ​​कि नई जीआईएल बुद्धि भी है, प्रदर्शन अभी भी बदतर है ... http://www.dabeaz.com/python/NewGIL.pdf – Basic

18

नीचे एक मूल थ्रेडिंग नमूना है। यह 20 धागे पैदा करेगा; प्रत्येक धागा इसके धागे संख्या का उत्पादन करेगा। इसे चलाएं और उस क्रम का निरीक्षण करें जिसमें वे प्रिंट करते हैं।

import threading 
class Foo (threading.Thread): 
    def __init__(self,x): 
     self.__x = x 
     threading.Thread.__init__(self) 
    def run (self): 
      print str(self.__x) 

for x in xrange(20): 
    Foo(x).start() 

जैसा कि आपने पाइथन धागे पर संकेत दिया है समय-टुकड़ा के माध्यम से लागू किया गया है। इस तरह वे "समांतर" प्रभाव प्राप्त करते हैं।

मेरे उदाहरण में मेरा फू क्लास थ्रेड फैलाता है, फिर मैं run विधि को लागू करता हूं, जहां वह कोड है जिसे आप थ्रेड में चलाने के लिए चाहते हैं। धागे को शुरू करने के लिए आप start() को थ्रेड ऑब्जेक्ट पर कॉल करते हैं, जो स्वचालित रूप से run विधि का आह्वान करेगा ...

बेशक, यह केवल मूल बातें है। अंततः आप थ्रेड सिंक्रनाइज़ेशन और संदेश पास करने के लिए सेमफोर, म्यूटेक्स और ताले के बारे में जानना चाहते हैं।

34

पायथन में थ्रेड के लिए एक काफी आसान भाषा है, लेकिन वहां चेतावनी हैं। ग्लोबल इंटरप्रेटर लॉक के बारे में आपको सबसे बड़ी चीज जानने की जरूरत है। यह केवल एक धागा दुभाषिया तक पहुंचने की अनुमति देता है। इसका अर्थ है दो चीजें: 1) आप शायद ही कभी पाइथन में लॉक स्टेटमेंट का उपयोग करके खुद को पाते हैं और 2) यदि आप मल्टी प्रोसेसर सिस्टम का लाभ लेना चाहते हैं, तो आपको अलग प्रक्रियाओं का उपयोग करना होगा। संपादित करें: मुझे यह भी इंगित करना चाहिए कि यदि आप जीआईएल के आसपास भी जाना चाहते हैं तो आप सी/सी ++ में कुछ कोड डाल सकते हैं।

इस प्रकार, आपको फिर से विचार करना होगा कि आप धागे का उपयोग क्यों करना चाहते हैं। यदि आप दोहरी कोर आर्किटेक्चर का लाभ उठाने के लिए अपने ऐप को समानांतर करना चाहते हैं, तो आपको अपने ऐप को कई प्रक्रियाओं में तोड़ने पर विचार करना होगा।

यदि आप प्रतिक्रिया में सुधार करना चाहते हैं, तो आपको थ्रेड का उपयोग करके समझना चाहिए। हालांकि अन्य विकल्प हैं, अर्थात् microthreading। वहाँ भी कुछ चौखटे है कि आप इस पर गौर करना चाहिए:

+0

@ जेएस - फिक्स्ड। वैसे भी वह सूची पुरानी थी। –

+0

यह मुझे गलत लगता है कि आपको बहु-कोर सिस्टम का लाभ उठाने के लिए - सभी ओवरहेड के साथ-साथ कई प्रक्रियाओं की आवश्यकता होती है। हमारे पास 32 लॉजिकल कोर के साथ कुछ सर्वर हैं - इसलिए मुझे कुशलतापूर्वक उपयोग करने के लिए 32 प्रक्रियाओं की आवश्यकता है? पागलपन – Basic

+0

@ बासिक - इन दिनों एक धागा शुरू करने की प्रक्रिया शुरू करने में ओवरहेड न्यूनतम है। मुझे लगता है कि यदि आप प्रति सेकंड हजारों प्रश्नों के बारे में बात कर रहे हैं तो आप समस्याओं को देखना शुरू कर सकते हैं, लेकिन फिर मैं पहली जगह ऐसी व्यस्त सेवा के लिए पायथन की पसंद पर सवाल उठाऊंगा। –

9

व्यक्तिगत श्रमिक I/O बाध्य संचालन कर रहे हैं तो पाइथन में धागे का उपयोग करें। यदि आप किसी मशीन पर एकाधिक कोरों में स्केल करने की कोशिश कर रहे हैं तो पाइथन के लिए अच्छा IPC ढांचा ढूंढें या एक अलग भाषा चुनें।

1

याद रखने की कोशिश करें कि जीआईएल कई कार्यों की उपस्थिति दिखाने के लिए हर बार चारों ओर मतदान करने के लिए सेट है। यह सेटिंग ठीक से ट्यून किया जा सकता है, लेकिन मैं सुझाव देता हूं कि थ्रेड कर रहे हैं या कई संदर्भ स्विच समस्याएं पैदा करने जा रहे हैं।

मैं प्रोसेसर पर एकाधिक माता-पिता का सुझाव देने के लिए और उसी कोर पर नौकरियों की तरह रखने की कोशिश करता हूं।

2

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

यदि आपको आगे देखने के लिए वास्तव में बड़े पैमाने पर समानांतरता की आवश्यकता है, लेकिन यदि आप केवल एक कंप्यूटर या कुछ अलग-अलग लोगों के सभी स्तरों पर स्केल करना चाहते हैं, तो बिना किसी व्यापक ढांचे को लागू करने के लिए, यह आपके लिए है।

संबंधित मुद्दे