लिनक्स में थ्रेड्स बनाम प्रोसेस


253

मैंने हाल ही में कुछ लोगों को यह कहते सुना है कि लिनक्स में, थ्रेड्स के बजाय प्रक्रियाओं का उपयोग करना लगभग हमेशा बेहतर होता है, क्योंकि लिनक्स प्रक्रियाओं को संभालने में बहुत कुशल होता है, और क्योंकि थ्रेड्स से जुड़ी बहुत सारी समस्याएं (जैसे लॉकिंग) होती हैं। हालांकि, मुझे संदेह है, क्योंकि ऐसा लगता है कि धागे कुछ स्थितियों में बहुत बड़ा प्रदर्शन दे सकते हैं।

तो मेरा सवाल है, जब एक ऐसी स्थिति का सामना करना पड़ता है जो थ्रेड्स और प्रक्रियाएं दोनों बहुत अच्छी तरह से संभाल सकती हैं, तो क्या मुझे प्रक्रियाओं या थ्रेड्स का उपयोग करना चाहिए? उदाहरण के लिए, यदि मैं एक वेब सर्वर लिख रहा था, तो क्या मुझे प्रक्रियाओं या थ्रेड्स (या संयोजन) का उपयोग करना चाहिए?


क्या लिनक्स 2.4 के साथ कोई अंतर है?
मौविसील

3
लिनक्स 2.4 के तहत प्रक्रियाओं और थ्रेड्स के बीच का अंतर यह है कि थ्रेड्स प्रक्रिया की तुलना में अपने राज्य (पता स्थान, फ़ाइल हैंडल आदि) के अधिक हिस्सों को साझा करते हैं, जो आमतौर पर नहीं होते हैं। लिनक्स 2.6 के तहत एनपीटीएल उन्हें "थ्रेड समूह" देकर थोड़ा स्पष्ट करता है जो कि win32 और सोलारिस में "प्रक्रियाओं" की तरह एक सा है।
मार्क

6
समवर्ती प्रोग्रामिंग मुश्किल है। जब तक आपको बहुत उच्च प्रदर्शन की आवश्यकता नहीं होती है, तब तक आपके ट्रेडऑफ़ में सबसे महत्वपूर्ण पहलू डिबगिंग की कठिनाई होगी । इस संबंध में प्रक्रियाएं बहुत आसान समाधान बनाती हैं, क्योंकि सभी संचार स्पष्ट हैं (जांचना आसान है, लॉग इन करने के लिए)। इसके विपरीत, थ्रेड्स की साझा की गई मेमोरी उन स्थानों की गजलों का निर्माण करती है जहां एक धागा दूसरे पर गलत प्रभाव डाल सकता है।
लुत्ज प्रेचल

1
@LutzPrechelt - समवर्ती प्रोग्रामिंग बहु-थ्रेडेड और साथ ही बहु-प्रक्रिया हो सकती है। मैं नहीं देखता कि आप यह क्यों मान रहे हैं कि समवर्ती प्रोग्रामिंग मल्टी थ्रेडेड है। यह कुछ विशेष भाषा सीमाओं के कारण हो सकता है लेकिन सामान्य तौर पर यह दोनों हो सकता है।
.यानीकिट

2
मैं लुत्ज़ को केवल इस बात से जोड़ता हूं कि समवर्ती प्रोग्रामिंग मुश्किल है जो भी चुना जाता है - प्रक्रिया या धागे - लेकिन प्रक्रियाओं के उपयोग से समवर्ती प्रोग्रामिंग कई मामलों में आसान डिबगिंग के लिए बनाता है।
user2692263

जवाबों:


322

लिनक्स 1-1 सूत्रण मॉडल का उपयोग करता है, (कर्नेल के लिए) प्रक्रियाओं और थ्रेड्स के बीच कोई अंतर नहीं है - सब कुछ बस एक रन करने योग्य कार्य है। *

लिनक्स पर, सिस्टम कॉल cloneक्लोन करता है, जो साझा करने के एक विन्यास स्तर के साथ, एक कार्य है:

  • CLONE_FILES: एक ही फ़ाइल डिस्क्रिप्टर तालिका साझा करें (कॉपी बनाने के बजाय)
  • CLONE_PARENT: नए कार्य और पुराने (अन्यथा, बच्चे के getppid()माता-पिता के getpid()) के बीच माता-पिता-बच्चे के संबंध स्थापित न करें
  • CLONE_VM: एक ही मेमोरी स्पेस (एक गाय कॉपी बनाने के बजाय ) साझा करें

fork()कॉल clone(कम से कम साझा करने )और pthread_create()कॉल clone(सबसे साझा करने )। **

forkआईएनजी pthread_createतालिकाओं की प्रतिलिपि बनाने और मेमोरी के लिए गाय मैपिंग के कारण आईएनजी से थोड़ा अधिक खर्च होता है , लेकिन लिनक्स कर्नेल डेवलपर्स ने उन लागतों को कम करने की कोशिश की (और सफल)।

कार्यों के बीच स्विच करना, यदि वे समान मेमोरी स्पेस और विभिन्न तालिकाओं को साझा करते हैं, तो साझा न होने की तुलना में थोड़ा सस्ता होगा, क्योंकि डेटा पहले से ही कैश में लोड हो सकता है। हालाँकि, स्विचिंग कार्य अभी भी बहुत तेज़ है, भले ही कुछ भी साझा न किया गया हो - यह कुछ और है जिसे लिनक्स कर्नेल डेवलपर्स सुनिश्चित करने का प्रयास करते हैं (और सुनिश्चित करने में सफल होते हैं)।

वास्तव में, यदि आप मल्टी-प्रोसेसर सिस्टम पर हैं, तो साझा करना वास्तव में प्रदर्शन के लिए फायदेमंद नहीं हो सकता है: यदि प्रत्येक कार्य एक अलग प्रोसेसर पर चल रहा है, तो साझा मेमोरी को सिंक्रनाइज़ करना महंगा है।


* सरलीकृत। CLONE_THREADसंकेतों के वितरण का कारण बनता है (जिसे जरूरत है CLONE_SIGHAND, जो सिग्नल हैंडलर तालिका साझा करता है)।

** सरलीकृत। दोनों SYS_forkऔर SYS_clonesyscalls मौजूद हैं , लेकिन कर्नेल में, sys_forkऔर sys_cloneदोनों एक ही do_forkफ़ंक्शन के चारों ओर बहुत पतले रैपर हैं , जो अपने आप में एक पतला आवरण है copy_process। हाँ, नियम process, threadऔर taskलिनक्स कर्नेल में परस्पर विनिमय के बजाय उपयोग किए जाते हैं ...


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

26
@ सौरभ वास्तव में नहीं। आप आसानी से कर सकते हैं socket, bind, listen, fork, और उसके बाद कई प्रक्रियाओं है acceptएक ही सुन सॉकेट पर कनेक्शन। यदि यह व्यस्त है, तो एक प्रक्रिया स्वीकार करना बंद कर सकती है, और कर्नेल आने वाले कनेक्शन को दूसरी प्रक्रिया में भेज देगा (यदि कोई नहीं सुन रहा है, तो कर्नेल कतार या ड्रॉप होगा, listenबैकलॉग के आधार पर )। आपके पास उस से अधिक कार्य वितरण पर अधिक नियंत्रण नहीं है, लेकिन आमतौर पर यह काफी अच्छा है!
ephemient

2
@Bloodcount लिनक्स पर सभी प्रक्रिया / धागे एक ही तंत्र द्वारा बनाए गए हैं, जो एक मौजूदा प्रक्रिया / थ्रेड को क्लोन करता है। clone()यह निर्धारित करने के लिए फ़्लैग पारित किया गया कि कौन से संसाधन साझा किए गए हैं। एक कार्य unshare()किसी भी बाद के समय में संसाधन भी कर सकता है ।
ईपीएन

4
@ कार्तिकबालगुरु स्वयं कर्नेल के भीतर, task_structप्रत्येक कार्य के लिए है। इसे अक्सर कर्नेल कोड में "प्रक्रिया" कहा जाता है, लेकिन यह प्रत्येक रन करने योग्य थ्रेड से मेल खाता है। नहीं है process_struct; यदि s का एक समूह task_structउनकी thread_groupसूची से एक साथ जुड़ा हुआ है , तो वे उपयोगकर्ताओं के लिए समान "प्रक्रिया" हैं। "थ्रेड" के विशेष हैंडलिंग का थोड़ा सा हिस्सा है, उदाहरण के लिए सभी सिबलिंग थ्रेड्स को कांटा और निष्पादन पर रोक दिया जाता है, और केवल "मुख्य" थ्रेड में दिखाई देता है ls /proc/proc/pidहालांकि, यह सूचीबद्ध है /procया नहीं , इसके माध्यम से हर धागा सुलभ है ।
24

5
@KarthikBalaguru कर्नेल धागे और प्रक्रियाओं के बीच व्यवहार की एक निरंतरता का समर्थन करता है; उदाहरण के लिए, clone(CLONE_THREAD | CLONE_VM | CLONE_SIGHAND))आपको एक नया "थ्रेड" प्रदान करेगा , जो कार्यशील निर्देशिका, फ़ाइलों या तालों को साझा नहीं करता है, जबकि clone(CLONE_FILES | CLONE_FS | CLONE_IO)आपको एक "प्रक्रिया" देता है। अंतर्निहित प्रणाली क्लोनिंग द्वारा कार्य बनाती है; fork()और pthread_create()सिर्फ पुस्तकालय के कार्य हैं जो clone()अलग तरीके से आह्वान करते हैं (जैसा कि मैंने इस उत्तर में लिखा है)।
24

60

लिनक्स (और वास्तव में यूनिक्स) आपको एक तीसरा विकल्प देता है।

विकल्प 1 - प्रक्रियाएं

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

विकल्प 2 - धागे

एक स्टैंडअलोन निष्पादन योग्य बनाएं जो एक एकल थ्रेड के साथ शुरू होता है और कुछ कार्य करने के लिए अतिरिक्त थ्रेड्स बनाता है

विकल्प 3 - कांटा

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

हालाँकि, मेमोरी पेज कॉपी नहीं किए जाते हैं, वे कॉपी-ऑन-राइट होते हैं, इसलिए आमतौर पर कम मेमोरी का उपयोग किया जाता है जिसकी आप कल्पना कर सकते हैं।

एक वेब सर्वर प्रोग्राम पर विचार करें जिसमें दो चरण होते हैं:

  1. कॉन्फ़िगरेशन और रनटाइम डेटा पढ़ें
  2. पृष्ठ अनुरोध परोसें

यदि आप थ्रेड्स का उपयोग करते हैं, तो चरण 1 एक बार किया जाएगा, और चरण 2 कई थ्रेड्स में किया जाएगा। यदि आपने "पारंपरिक" प्रक्रियाओं का उपयोग किया है, तो चरण 1 और 2 को प्रत्येक प्रक्रिया के लिए दोहराया जाना चाहिए, और कॉन्फ़िगरेशन और रनटाइम डेटा को डुप्लिकेट करने के लिए मेमोरी को संग्रहीत करना होगा। यदि आपने कांटा () का उपयोग किया है, तो आप चरण 1 को एक बार कर सकते हैं, और फिर कांटा (), रनटाइम डेटा और कॉन्फ़िगरेशन को स्मृति में छोड़ कर, अछूता, कॉपी नहीं किया गया है।

तो वास्तव में तीन विकल्प हैं।


7
@ क्वर्टी फोर्किंग वह शांत नहीं है, यह बहुत सारे पुस्तकालयों को सूक्ष्म तरीकों से तोड़ता है (यदि आप उन्हें मूल प्रक्रिया में उपयोग करते हैं)। यह अप्रत्याशित व्यवहार बनाता है जो अनुभवी प्रोग्रामर को भी भ्रमित करता है।
MarkR

2
@MarkR आपको कुछ उदाहरण या लिंक दे सकता है कि कैसे forking पुस्तकालय को तोड़ता है और अप्रत्याशित व्यवहार बनाता है?
एहतेश चौधरी 19

18
यदि एक प्रक्रिया खुले mysql कनेक्शन के साथ कांटा करती है, तो खराब चीजें होती हैं, क्योंकि सॉकेट को दो प्रक्रियाओं के बीच साझा किया जाता है। यहां तक ​​कि अगर केवल एक प्रक्रिया कनेक्शन का उपयोग करती है, तो दूसरा इसे बंद होने से रोकता है।
MarkR

1
फोर्क () सिस्टम कॉल POSIX द्वारा निर्दिष्ट है (जिसका अर्थ है कि यह किसी भी यूनिक्स सिस्टम पर उपलब्ध है), यदि आपने अंतर्निहित लिनक्स एपीआई का उपयोग किया है, जो क्लोन () सिस्टम कॉल है, तो आपके पास वास्तव में लिनक्स में केवल तीन से अधिक विकल्प हैं। ।
रेयान

2
@MarkR सॉकेट का बंटवारा डिज़ाइन द्वारा किया गया है। इसके अलावा, या तो प्रक्रियाओं में सॉकेट बंद करने से पहले linux.die.net/man/2/shutdown का उपयोग करके सॉकेट बंद कर सकते हैं ।
लेलंथ्रान

53

यह बहुत सारे कारकों पर निर्भर करता है। प्रक्रियाएं थ्रेड्स की तुलना में अधिक भारी होती हैं, और इसमें एक उच्च स्टार्टअप और शटडाउन लागत होती है। इंटरप्रोसेस कम्युनिकेशन (IPC) इंटरथ्रेड कम्युनिकेशन की तुलना में कठिन और धीमा है।

इसके विपरीत, प्रक्रियाएं थ्रेड्स की तुलना में अधिक सुरक्षित और सुरक्षित हैं, क्योंकि प्रत्येक प्रक्रिया अपने स्वयं के वर्चुअल एड्रेस स्पेस में चलती है। यदि कोई प्रक्रिया क्रैश हो जाती है या बफर ओवररन हो जाता है, तो यह किसी अन्य प्रक्रिया को प्रभावित नहीं करता है, जबकि यदि कोई थ्रेड क्रैश हो जाता है, तो यह प्रक्रिया में अन्य सभी थ्रेड्स को नीचे ले जाता है, और यदि किसी थ्रेड पर बफर ओवररन होता है, तो यह खुल जाता है सभी थ्रेड्स में एक सुरक्षा छेद।

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


9
एडम का जवाब एक कार्यकारी ब्रीफिंग के रूप में अच्छी तरह से काम करेगा। अधिक विस्तार के लिए, मार्कआर और एपिमिएंट अच्छी व्याख्या प्रदान करते हैं। उदाहरणों के साथ एक बहुत ही विस्तृत विवरण cs.cf.ac.uk/Dave/C/node29.html पर पाया जा सकता है, लेकिन यह कुछ हिस्सों में दिनांकित प्रतीत होता है।
साइबरफॉनिक

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

IPC का उपयोग करना कठिन है लेकिन क्या होगा अगर कोई "साझा मेमोरी" का उपयोग करता है?
अभिरोरा

11

अन्य लोगों ने विचार विमर्श किया है।

शायद महत्वपूर्ण अंतर यह है कि थ्रेड्स की तुलना में विंडोज प्रक्रियाओं में भारी और महंगे हैं, और लिनक्स में यह अंतर बहुत छोटा है, इसलिए समीकरण एक अलग बिंदु पर संतुलित होता है।


9

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

एक समकालीन लिनक्स (2.6.x) में एक थ्रेड की तुलना में प्रक्रिया के संदर्भ स्विच के बीच प्रदर्शन में बहुत अंतर नहीं है (केवल एमएमयू सामान थ्रेड के लिए अतिरिक्त है)। साझा पता स्थान के साथ समस्या है, जिसका अर्थ है कि एक थ्रेड में दोषपूर्ण पॉइंटर पैरेंट प्रक्रिया की मेमोरी या उसी एड्रेस स्पेस में किसी अन्य थ्रेड की दूषित कर सकता है।

एक प्रक्रिया MMU द्वारा संरक्षित है, इसलिए एक दोषपूर्ण पॉइंटर केवल एक सिग्नल 11 और कोई भ्रष्टाचार का कारण नहीं होगा।

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

आपको क्या लगता है कि थ्रेड लिनक्स पर इतना बड़ा प्रदर्शन क्यों है? क्या आपके पास इसके लिए कोई डेटा है, या यह सिर्फ एक मिथक है?


1
हां, मेरे पास कुछ डेटा है। मैंने एक परीक्षण चलाया जो 100,000 प्रक्रियाएं बनाता है और एक परीक्षण जो 100,000 धागे बनाता है। थ्रेड संस्करण लगभग 9x तेज (प्रक्रियाओं के लिए 17.38 सेकंड, थ्रेड्स के लिए 1.93) चला। अब यह केवल निर्माण समय का परीक्षण करता है, लेकिन अल्पकालिक कार्यों के लिए, सृजन का समय महत्वपूर्ण हो सकता है।
user17918

4
@ user17918 - क्या यह संभव है कि आपके द्वारा उपयोग किए गए कोड को उपरोक्त उल्लिखित समय की गणना के लिए साझा किया जाए ..
कोडिंगफ्रीक

एक बड़ी भिन्न प्रक्रिया के साथ कर्नेल हर प्रक्रिया के लिए पेज टेबल बनाता है और थिसिस केवल एक पेज टेबल का उपयोग करता है, इसलिए मुझे लगता है कि थ्रेड सामान्य हैं तब प्रक्रियाएं तेज हो जाती हैं
c4f4t0r

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

5

आपके कार्यों को कितनी मजबूती से युग्मित किया गया है?

यदि वे एक दूसरे से स्वतंत्र रूप से रह सकते हैं, तो प्रक्रियाओं का उपयोग करें। यदि वे एक-दूसरे पर भरोसा करते हैं, तो धागे का उपयोग करें। इस तरह आप अन्य कार्यों के संचालन में हस्तक्षेप किए बिना एक बुरी प्रक्रिया को मार सकते हैं और पुनः आरंभ कर सकते हैं।


4

आगे के मामलों को जटिल करने के लिए, थ्रेड-लोकल स्टोरेज , और यूनिक्स साझा की गई मेमोरी जैसी कोई चीज है ।

थ्रेड-लोकल स्टोरेज प्रत्येक थ्रेड को वैश्विक ऑब्जेक्ट का एक अलग उदाहरण है। केवल एक बार जब मैंने इसका उपयोग किया है, तो एक RTOS में चलने वाले एप्लिकेशन कोड के लिए linux / windows पर एक इम्यूलेशन वातावरण का निर्माण किया गया था। RTOS में प्रत्येक कार्य एक प्रक्रिया थी, जिसमें स्वयं का पता स्थान होता है, अनुकरण के वातावरण में, प्रत्येक कार्य एक थ्रेड (एक साझा स्थान के साथ) था। सिंग्लेट्स जैसी चीजों के लिए टीएलएस का उपयोग करके, हम प्रत्येक थ्रेड के लिए एक अलग उदाहरण बनाने में सक्षम थे, जैसे 'वास्तविक' आरटीआई वातावरण के तहत।

साझा मेमोरी (स्पष्ट रूप से) आपको एक ही मेमोरी तक कई प्रक्रियाओं के प्रदर्शन लाभ दे सकती है, लेकिन प्रक्रियाओं को ठीक से सिंक्रनाइज़ करने की लागत / जोखिम पर। ऐसा करने का एक तरीका यह है कि एक प्रक्रिया साझा स्मृति में एक डेटा संरचना बनाएं, और फिर पारंपरिक अंतर-प्रक्रिया संचार (जैसे एक नामित पाइप) के माध्यम से उस संरचना को एक हैंडल भेजें।


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

4

LINUX के साथ मेरे हाल के काम में पुस्तकालयों के बारे में पता होना एक बात है। यदि आप थ्रेड्स का उपयोग कर रहे हैं, तो सुनिश्चित करें कि आपके द्वारा उपयोग किए जा सकने वाले किसी भी लाइब्रेरी थ्रेड्स सुरक्षित हैं। इसने मुझे कई बार जलाया। विशेष रूप से libxml2 बॉक्स से थ्रेड-सुरक्षित नहीं है। इसे थ्रेड सेफ के साथ संकलित किया जा सकता है लेकिन यह वह नहीं है जो आपको एप्टीट्यूड इंस्टॉल के साथ मिलता है।


3

मुझे आपकी बातों से सहमत होना पड़ेगा। जब हम अपने क्लस्टर ( xhplऔर ऐसे) को बेंचमार्क करते हैं , तो हमें थ्रेड्स पर प्रक्रियाओं के साथ हमेशा बेहतर प्रदर्शन मिलता है।</anecdote>


3

थ्रेड / प्रक्रिया के बीच का निर्णय इस बात पर थोड़ा निर्भर करता है कि आप इसका क्या उपयोग कर रहे हैं। एक प्रक्रिया के साथ एक लाभ यह है कि इसमें एक पीआईडी ​​है और माता-पिता को समाप्त किए बिना भी मारा जा सकता है।

एक वेब सर्वर के एक वास्तविक दुनिया उदाहरण के लिए, अपाचे 1.3 का उपयोग केवल कई प्रक्रियाओं का समर्थन करने के लिए किया जाता था, लेकिन 2.0 में उन्होंने एक अमूर्त जोड़ दिया ताकि आप दोनों के बीच में स्वैप कर सकें। टिप्पणियाँ इस बात से सहमत लगती हैं कि प्रक्रियाएँ अधिक मजबूत हैं, लेकिन थ्रेड्स थोड़ा बेहतर प्रदर्शन दे सकते हैं (उन खिड़कियों को छोड़कर जहाँ प्रक्रियाओं के लिए प्रदर्शन बेकार है और आप केवल थ्रेड्स का उपयोग करना चाहते हैं)।


2

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


क्या मतलब है आपका कोई फायदा नहीं? GUI थ्रेड में भारी गणना करने के बारे में कैसे? सीपीयू लोड होने पर कोई फर्क नहीं पड़ता कि उन्हें उपयोगकर्ता अनुभव के एक बिंदु से समानांतर धागे पर ले जाना बेहतर होगा।
olegst

2

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


2

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

"प्रक्रियाओं या थ्रेड को लागू करने के लिए कोई आंतरिक संरचनाएं नहीं हैं, इसके बजाय एक संरचनात्मक कार्य_ बाधा है जो कार्य के लिए एक सार निर्धारण इकाई का वर्णन करती है"

इसके अलावा, लिनुस टॉर्वाल्ड्स के अनुसार, आपको प्रक्रिया बनाम थ्रेड के बारे में बिल्कुल भी नहीं सोचना चाहिए और क्योंकि यह बहुत सीमित है और एकमात्र अंतर COE या प्रसंग का निष्पादन "माता-पिता से पता स्थान" या साझा पता स्थान के संदर्भ में है। वास्तव में वह यहाँ अपनी बात बनाने के लिए एक वेब सर्वर उदाहरण का उपयोग करता है (जो अत्यधिक पढ़ने की सलाह देते हैं) ।

लिनक्स कर्नेल प्रलेखन का पूरा श्रेय


-3

यदि आपको संसाधनों को साझा करने की आवश्यकता है, तो आपको वास्तव में थ्रेड्स का उपयोग करना चाहिए।

इस तथ्य पर भी विचार करें कि थ्रेड्स के बीच संदर्भ स्विच प्रक्रियाओं के बीच संदर्भ स्विच की तुलना में बहुत कम महंगे हैं।

मुझे स्पष्ट रूप से अलग-अलग प्रक्रियाओं के साथ जाने का कोई कारण नहीं दिखता है जब तक कि आपके पास ऐसा करने का एक अच्छा कारण नहीं है (सुरक्षा, सिद्ध प्रदर्शन परीक्षण, आदि ...)


3
मेरे पास संपादन करने के लिए प्रतिनिधि है, लेकिन मैं बिल्कुल सहमत नहीं हूं। लिनक्स पर प्रक्रियाओं के बीच संदर्भ स्विच धागे के बीच संदर्भ स्विच के रूप में लगभग सस्ता है।
ephemient
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.