linux - फोर्किंग बनाम थ्रेडिंग




multithreading unix (2)

मैंने अपने अनुप्रयोगों में पहले थ्रेडिंग का उपयोग किया है और इसकी अवधारणाओं को अच्छी तरह से जानता हूं, लेकिन हाल ही में मेरे ऑपरेटिंग सिस्टम व्याख्यान में मुझे कांटा () मिला। जो थ्रेडिंग के समान कुछ है।

मैंने उनके बीच अंतर खोजा और मुझे पता चला कि:

  1. फोर्क और कुछ नहीं बल्कि एक नई प्रक्रिया है जो बिल्कुल पुरानी या मूल प्रक्रिया की तरह दिखती है लेकिन फिर भी यह अलग प्रक्रिया आईडी के साथ एक अलग प्रक्रिया है और इसकी अपनी स्मृति है।
  2. थ्रेड्स हल्के वजन की प्रक्रिया है जो कम उपरि है

लेकिन, मेरे मन में अभी भी कुछ सवाल हैं।

  1. जब आपको थ्रेडिंग और वाइस-वर्स पर कांटा () पसंद करना चाहिए?
  2. यदि मैं एक बाहरी एप्लिकेशन को एक बच्चे के रूप में कॉल करना चाहता हूं, तो क्या मुझे इसे करने के लिए कांटा () या थ्रेड्स का उपयोग करना चाहिए?
  3. Google खोज करते समय मैंने पाया कि लोग यह कहते हैं कि एक थ्रेड के अंदर कांटा () को कॉल करना बुरी बात है। जब लोग इसी तरह की चीजों को करते हैं तो लोग एक धागे के अंदर कांटा () क्यों बुलाना चाहते हैं?
  4. क्या यह सही है कि कांटा () मल्टीप्रोसेसर सिस्टम का लाभ नहीं उठा सकता क्योंकि माता-पिता और बच्चे की प्रक्रिया एक साथ नहीं चलती है?

एक कांटे की प्रक्रिया को एक भारी-वजन प्रक्रिया कहा जाता है, जबकि एक थ्रेडेड प्रक्रिया को हल्के-वजन की प्रक्रिया कहा जाता है।

उनके बीच अंतर निम्नलिखित हैं:

  1. एक कांटेदार प्रक्रिया को एक बाल प्रक्रिया माना जाता है जबकि एक थ्रेडेड प्रक्रिया को एक सहोदर कहा जाता है।
  2. कांटेक्ट प्रोसेस में कोई संसाधन जैसे कोड, डेटा, स्टैक आदि को पेरेंट प्रक्रिया के साथ साझा नहीं किया जाता है जबकि एक थ्रेडेड प्रक्रिया कोड को साझा कर सकती है, लेकिन इसका अपना स्टैक है।
  3. प्रोसेस स्विचिंग के लिए OS की सहायता की आवश्यकता होती है लेकिन थ्रेड स्विचिंग की आवश्यकता नहीं होती है
  4. एकाधिक प्रक्रियाएँ बनाना एक संसाधन गहन कार्य है जबकि कई सूत्र बनाना कम संसाधन गहन कार्य है
  5. प्रत्येक प्रक्रिया स्वतंत्र रूप से चल सकती है जबकि एक धागा दूसरे थ्रेड डेटा को पढ़ / लिख सकता है। धागा और प्रक्रिया lecture

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

विशेष रूप से आपके प्रश्नों के लिए:

जब आपको थ्रेडिंग और वाइस-वर्स पर कांटा () पसंद करना चाहिए?

एक यूनिक्स प्रणाली पर जहां आप एक कार्यकर्ता को तत्काल करने की तुलना में कहीं अधिक जटिल कार्य कर रहे हैं, या आप अलग-अलग प्रक्रियाओं के अंतर्निहित सुरक्षा सैंडबॉक्सिंग चाहते हैं।

यदि मैं एक बाहरी एप्लिकेशन को एक बच्चे के रूप में कॉल करना चाहता हूं, तो क्या मुझे इसे करने के लिए कांटा () या थ्रेड्स का उपयोग करना चाहिए?

यदि बच्चा समान कोड के साथ माता-पिता के लिए एक समान कार्य करेगा, तो कांटा का उपयोग करें। छोटे उपशीर्षक के लिए थ्रेड्स का उपयोग करें। अलग-अलग बाहरी प्रक्रियाओं के लिए न तो उपयोग करें, बस उन्हें उचित एपीआई कॉल के साथ कॉल करें।

Google खोज करते समय मैंने पाया कि लोग यह कहते हैं कि एक थ्रेड के अंदर कांटा () को कॉल करना बुरी बात है। जब लोग इसी तरह की चीजों को करते हैं तो लोग एक धागे के अंदर एक कांटा () क्यों बुलाना चाहते हैं?

पूरी तरह से यकीन नहीं है, लेकिन मुझे लगता है कि यह एक प्रक्रिया और बहुत सारे सबथ्रेड्स की नकल करने के लिए कम्प्यूटेशनल रूप से महंगा है।

क्या यह सही है कि कांटा () मल्टीप्रोसेसर सिस्टम का लाभ नहीं उठा सकता क्योंकि माता-पिता और बच्चे की प्रक्रिया एक साथ नहीं चलती है?

यह गलत है, कांटा एक नई प्रक्रिया बनाता है जो तब ओएस कार्य अनुसूचक में प्रक्रियाओं के लिए उपलब्ध सभी सुविधाओं का लाभ उठाता है।





fork