लिनक्स 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_clone
syscalls मौजूद हैं , लेकिन कर्नेल में, sys_fork
और sys_clone
दोनों एक ही do_fork
फ़ंक्शन के चारों ओर बहुत पतले रैपर हैं , जो अपने आप में एक पतला आवरण है copy_process
। हाँ, नियम process
, thread
और task
लिनक्स कर्नेल में परस्पर विनिमय के बजाय उपयोग किए जाते हैं ...