लिनक्स की तुलना में विंडोज पर एक नई प्रक्रिया को अधिक महंगा क्यों बनाया जा रहा है?

Question

मैंने सुना है कि विंडोज बॉक्स पर एक नई प्रक्रिया बनाना लिनक्स की तुलना में अधिक महंगा है। क्या ये सच है? क्या कोई इसके लिए तकनीकी कारणों की व्याख्या कर सकता है कि यह अधिक महंगा क्यों है और उन कारणों के पीछे डिजाइन निर्णयों के लिए कोई ऐतिहासिक कारण प्रदान करें?

Answer 1

mweerden: NT को पहले दिन से बहु-उपयोगकर्ता के लिए डिज़ाइन किया गया है, इसलिए यह वास्तव में एक कारण नहीं है। हालाँकि, आप इस बारे में सही हैं कि निर्माण प्रक्रिया एनटी की तुलना में एनटी की तुलना में एनटी पर कम महत्वपूर्ण भूमिका निभाती है, यूनिक्स के विपरीत, मल्टीप्रोसेसिंग पर मल्टीथ्रेडिंग का पक्षधर है।

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

प्रक्रिया निर्माण की गति पर चर्चा करते समय, NT और Windows / Win32 के बीच अंतर करना शायद एक अच्छा विचार है। जहाँ तक NT (यानी कर्नेल ही) चला जाता है, मुझे नहीं लगता कि प्रोसेस क्रिएशन (NtCreateProcess) और थ्रेड क्रिएशन (NtCreateThread) औसत यूनिक्स की तरह काफी धीमा है। थोड़ा और अधिक हो सकता है, लेकिन मुझे यहां प्रदर्शन के अंतर का प्राथमिक कारण नहीं दिखता है।

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

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

Comments

फोर्क को हमेशा निष्पादन () द्वारा पालन नहीं किया जाता है, और लोग अकेले फोर्क () की परवाह करते हैं। अपाचे 1.3 विंडोज पर लिनक्स और थ्रेड्स पर कांटा () (निष्पादन के बिना) का उपयोग करता है, भले ही कई मामलों में प्रक्रियाओं को जरूरत पड़ने और पूल में रखने से पहले कांटा हो।

— ब्लिसोरब्लेड

निश्चित रूप से नहीं, 'vfork' कमांड, जो आपके द्वारा वर्णित 'जस्ट कॉल एक्जीक्यूट' परिदृश्य के लिए बनाया गया है।

— क्रिस हुआंग-लीवर

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

— दान मोल्डिंग

-1। दावा है कि सॉफ्टवेयर 'खराब पोर्टेड' है क्योंकि यह अनुकूलता cruft से भरा खराब तरीके से डिजाइन किए गए ऑपरेटिंग सिस्टम पर अच्छी तरह से नहीं चलता है जो प्रक्रिया निर्माण को धीमा कर देता है वह हास्यास्पद है।

— माइल्स रुट

@MilesRout के लक्ष्य को ध्यान में रखते हुए उस सिस्टम की ताकत और कमियों के साथ एक नए लक्ष्य प्रणाली पर चलने के लिए सॉफ़्टवेयर को संशोधित करना है। खराब पोर्टेड सॉफ्टवेयर प्रदर्शन है खराब पोर्टेड सॉफ्टवेयर, बाधाओं ऑपरेटिंग सिस्टम प्रदान करता है की परवाह किए बिना।

— डिजीसिपिरल

Answer 2

यूनिक्स में एक 'फोर्क' सिस्टम कॉल है जो वर्तमान प्रक्रिया को दो में विभाजित करता है, और आपको एक दूसरी प्रक्रिया देता है जो पहले के समान है (कांटा कॉल से वापसी को मापता है)। चूंकि नई प्रक्रिया का पता स्थान पहले से ही है और इसे चलाना विंडोज में 'क्रिएटप्रोसेस' कहलाने की तुलना में सस्ता होना चाहिए और इसे एक्साई इमेज, संबंधित डीएलएस आदि लोड करना चाहिए।

कांटा मामले में, ओएस दोनों नई प्रक्रियाओं से जुड़े मेमोरी पेजों के लिए 'कॉपी-ऑन-राइट' शब्दार्थ का उपयोग कर सकता है ताकि यह सुनिश्चित हो सके कि प्रत्येक को उन पृष्ठों की अपनी कॉपी मिलती है जिन्हें वे बाद में संशोधित करते हैं।

Comments

यह तर्क केवल तब लागू होता है जब आप वास्तव में क्षमा कर रहे हों। यदि आप एक नई प्रक्रिया शुरू कर रहे हैं, तो यूनिक्स पर आपको अभी भी कांटा और निष्पादन करना है। विंडोज और यूनिक्स दोनों में लिखने पर कॉपी है। यदि आप किसी एप्लिकेशन की दूसरी प्रति चलाते हैं, तो Windows निश्चित रूप से लोड किए गए EXE का पुन: उपयोग करेगा। मुझे नहीं लगता कि आपका स्पष्टीकरण सही है, क्षमा करें।

— योएल Spolsky

निष्पादन पर अधिक () और कांटा () vipinkrsahu.blogspot.com/search/label/system%20programming

— webkul

मैंने अपने उत्तर में कुछ प्रदर्शन डेटा जोड़े। stackoverflow.com/a/51396188/537980 आप देख सकते हैं कि यह तेज है।

— ctrl-alt-delor-

Answer 3

जेपी ने क्या कहा: इस प्रक्रिया में अधिकांश ओवरहेड Win32 स्टार्टअप से संबंधित है।

कांटा कांटा वास्तव में Windows NT कर्नेल का समर्थन करता है। एसएफयू (विंडोज के लिए माइक्रोसॉफ्ट का यूनिक्स पर्यावरण) उनका उपयोग करता है। हालाँकि, Win32 कांटा का समर्थन नहीं करता है। SFU प्रक्रियाएँ Win32 प्रक्रियाएँ नहीं हैं। SFU Win32 के लिए रूढ़िवादी है: वे दोनों पर्यावरण उपतंत्र एक ही कर्नेल पर निर्मित हैं।

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

Win32 रनटाइम लाइब्रेरीज़ (कर्नेल 32.dll, इत्यादि) स्टार्टअप पर बहुत सारी रजिस्ट्री रीड और इनिशियलाइज़ेशन करते हैं जो UNIX, SFU या देशी प्रक्रियाओं पर लागू नहीं होते हैं।

मूल प्रक्रियाएं (बिना पर्यावरण उपतंत्र के) बनाने के लिए बहुत तेज़ हैं। SFU प्रक्रिया निर्माण के लिए Win32 की तुलना में बहुत कम करता है, इसलिए इसकी प्रक्रियाएँ भी तेजी से बनती हैं।

2019 के लिए अद्यतन: LXSS जोड़ें: लिनक्स के लिए विंडोज सबसिस्टम

विंडोज 10 के लिए SFU की जगह LXSS पर्यावरण सबसिस्टम है। यह 100% कर्नेल मोड है और इसके लिए किसी भी IPC की आवश्यकता नहीं है जो Win32 के लिए जारी है। इन प्रक्रियाओं के लिए Syscall को सीधे lxss.sys / lxcore.sys पर निर्देशित किया जाता है, इसलिए फोर्क () या कॉल बनाने वाली अन्य प्रक्रिया में केवल निर्माता के लिए 1 सिस्टम कॉल की लागत होती है, कुल। [एक डेटा क्षेत्र जिसे उदाहरण कहा जाता है] सभी एलएक्स प्रक्रियाओं, थ्रेड्स और रनटाइम स्थिति का ट्रैक रखता है।

LXSS प्रक्रियाएं देशी प्रक्रियाओं पर आधारित होती हैं, न कि Win32 प्रक्रियाओं पर। संगतता इंजन की तरह सभी Win32 विशिष्ट सामान बिल्कुल भी नहीं लगे हुए हैं।

Answer 4

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

socket_accept ()
कांटा()
अगर (बच्चा)
    handleRequest ()
अन्य
    goOnBeingParent ()

इसलिए कांटा का कार्यान्वयन तेजी से होना था और समय के साथ बहुत सारे अनुकूलन लागू हो गए हैं। Microsoft नई प्रक्रियाओं और इंटरप्रोसेस संचार के उपयोग के बजाय CreateThread या फ़ाइबर का समर्थन करता है। मुझे लगता है कि CreateProcess को कांटे से तुलना करने के लिए यह "उचित" नहीं है क्योंकि वे विनिमेय नहीं हैं। फोर्क / एक्ज़िक्यूशन को क्रिएप्रोसेस से तुलना करना शायद अधिक उचित है।

Comments

आपके अंतिम बिंदु के बारे में: Fork () CreateProcess () के साथ विनिमेय नहीं है, लेकिन एक यह भी कह सकता है कि Windows को कांटा () लागू करना चाहिए, क्योंकि यह अधिक लचीलापन देता है।

— ब्लिसॉर्बलेड

आह, क्रिया टू बी।

— acib708

लेकिन लिनक्स में कांटा + निष्पादन, MS-Windows पर CreateThread की तुलना में तेज़ है। और लिनक्स अपने आप पर कांटा भी तेज कर सकता है। हालाँकि आप इसकी तुलना करते हैं, एमएस धीमा है।

— सीटीएल-अल्ट-डेलोर

Answer 5

इस मामले की कुंजी दोनों प्रणालियों का ऐतिहासिक उपयोग है, मुझे लगता है। विंडोज (और उससे पहले डॉस) व्यक्तिगत कंप्यूटर के लिए मूल रूप से एकल-उपयोगकर्ता सिस्टम हैं । जैसे, इन प्रणालियों को आम तौर पर हर समय बहुत सारी प्रक्रियाएं बनाने की आवश्यकता नहीं होती है; (बहुत) सीधे शब्दों में कहें, एक प्रक्रिया केवल तब बनाई जाती है जब यह एक अकेला उपयोगकर्ता इसे अनुरोध करता है (और हम इंसान बहुत तेज, अपेक्षाकृत बोलने का काम नहीं करते हैं)।

यूनिक्स-आधारित सिस्टम मूल रूप से मल्टी-उपयोगकर्ता सिस्टम और सर्वर हैं। विशेष रूप से उत्तरार्द्ध के लिए ऐसी प्रक्रियाएं (जैसे मेल या http डेमन) होना असामान्य नहीं है जो विशिष्ट नौकरियों को संभालने के लिए प्रक्रियाओं को विभाजित करती हैं (जैसे एक आने वाले कनेक्शन की देखभाल करना)। ऐसा करने में एक महत्वपूर्ण कारक सस्ती forkविधि है (जो कि, रॉब वॉकर ( 47865 ) द्वारा उल्लेखित है , शुरू में नई बनाई गई प्रक्रिया के लिए उसी मेमोरी का उपयोग करता है) जो बहुत उपयोगी है क्योंकि नई प्रक्रिया में तुरंत सभी जानकारी की आवश्यकता होती है।

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

डिस्क्लेमर: मैं किसी भी तरह से इस मामले का विशेषज्ञ नहीं हूं, इसलिए मुझे गलत होने पर माफ कर दें।

Answer 6

उह, "यह इस तरह से बेहतर है" के औचित्य का एक बहुत कुछ हो रहा है।

मुझे लगता है कि लोगों को "शोस्टॉपर" पढ़ने से फायदा हो सकता है; Windows NT के विकास के बारे में पुस्तक।

Windows NT पर एक प्रक्रिया में DLL के रूप में चलने वाली संपूर्ण कारण यह था कि वे अलग-अलग प्रक्रियाओं के रूप में बहुत धीमी थीं।

यदि आप नीचे उतरे और गंदे हुए तो आप पाएंगे कि लाइब्रेरी लोडिंग की रणनीति समस्या है।

यूनीवर्स (सामान्य रूप से) पर साझा लाइब्रेरी (DLL) के कोड सेगमेंट वास्तव में साझा किए जाते हैं।

Windows NT प्रति प्रक्रिया DLL की एक प्रति लोड करता है, क्योंकि यह लोड होने के बाद लाइब्रेरी कोड खंड (और निष्पादन योग्य कोड खंड) में हेरफेर करता है। (यह बताता है कि आपका डेटा कहां है?)

इससे पुस्तकालयों में कोड सेगमेंट पुन: प्रयोज्य नहीं होते हैं।

तो, NT प्रक्रिया बनाएँ वास्तव में बहुत महंगा है। और नीचे की तरफ, यह मेमोरी में डीएलएल की कोई सराहनीय बचत नहीं करता है, लेकिन इंटर-ऐप निर्भरता समस्याओं के लिए एक मौका है।

कभी-कभी यह वापस कदम रखने के लिए इंजीनियरिंग में भुगतान करता है और कहता है, "अब, अगर हम वास्तव में चूसने के लिए इसे डिजाइन करने जा रहे थे, तो यह कैसा दिखेगा?"

मैंने एक एम्बेडेड सिस्टम के साथ काम किया जो एक समय में एक बार काफी मनमौजी था, और एक दिन इसे देखा और महसूस किया कि यह एक कैविटी मैग्नेट्रॉन है, जिसमें माइक्रोवेव कैविटी में इलेक्ट्रॉनिक्स हैं। हमने इसके बाद इसे और अधिक स्थिर (और माइक्रोवेव की तरह कम) बनाया।

Comments

कोड खंड पुन: प्रयोज्य हैं जब तक कि DLL अपने पसंदीदा आधार पते पर लोड नहीं हो जाता। परंपरागत रूप से आपको यह सुनिश्चित करना चाहिए कि आप सभी DLL के लिए गैर-परस्पर विरोधी आधार पते सेट करें जो आपकी प्रक्रियाओं में लोड होंगे, लेकिन यह ASLR के साथ काम नहीं करता है।

— माइक डिमिक्क

सभी DLL को रीबेस करने के लिए कुछ टूल है, है न? यह सुनिश्चित नहीं है कि यह एएसएलआर के साथ क्या करता है।

— ज़ैन लिंक्स

कोड अनुभागों को साझा करना ASLR- सक्षम सिस्टम पर भी काम करता है।

— जोहान्स पासिंग

@ मायकेमिडिक तो हर कोई, एक DLL बनाने के लिए सहयोग करना है, यह सुनिश्चित करने के लिए कि कोई संघर्ष नहीं है, या क्या आप लोड करने से पहले, सिस्टम स्तर पर उन सभी को पैच करते हैं?

— सीटीएल-अल्ट-डेलोर

Answer 7

संक्षिप्त उत्तर "सॉफ्टवेयर लेयर और कंपोनेंट्स" है।

विंडोज़ SW आर्किटेक्चर में कुछ अतिरिक्त परतें और घटक हैं जो यूनिक्स पर मौजूद नहीं हैं या यूनिक्स पर कर्नेल के अंदर सरलीकृत और संभाले हुए हैं।

यूनिक्स पर, कांटा और निष्पादन कर्नेल के लिए सीधे कॉल हैं।

विंडोज पर, कर्नेल एपीआई का सीधे उपयोग नहीं किया जाता है, इसके शीर्ष पर win32 और कुछ अन्य घटक हैं, इसलिए प्रक्रिया निर्माण को अतिरिक्त परतों के माध्यम से जाना चाहिए और फिर नई प्रक्रिया को उन परतों और घटकों से शुरू या कनेक्ट करना होगा।

काफी समय से शोधकर्ताओं और निगमों ने यूनिक्स को एक समान रूप से तोड़ने का प्रयास किया है, आमतौर पर मच कर्नेल पर उनके प्रयोगों को आधार बनाते हुए ; एक प्रसिद्ध उदाहरण OS X है । हर बार जब वे प्रयास करते हैं, हालांकि, यह इतना धीमा हो जाता है कि वे कम से कम आंशिक रूप से टुकड़े को कर्नेल में स्थायी रूप से या उत्पादन शिपमेंट के लिए विलय कर देते हैं।

Comments

परतें जरूरी चीजों को धीमा नहीं करती हैं: मैंने बहुत सी परतों के साथ एक डिवाइस ड्राइवर लिखा है। सी। क्लीन कोड, साक्षर प्रोग्रामिंग, पढ़ने में आसान। यह परतों के बिना अत्यधिक अनुकूलित कोडांतरक में लिखे गए संस्करण की तुलना में तेज़ (मामूली) था।

— ctrl-alt-delor-

विडंबना यह है कि NT एक विशाल कर्नेल है (माइक्रो कर्नेल नहीं)

— सीटीएल-अल्ट-डेलोर

Answer 8

जैसा कि कुछ जवाबों में एमएस-विंडोज का कुछ औचित्य प्रतीत होता है जैसे

• “NT कर्नेल और Win32, एक ही बात नहीं हैं। यदि आप एनटी कर्नेल के लिए प्रोग्राम करते हैं तो यह इतना बुरा नहीं है ”- सच है, लेकिन जब तक आप पॉज़िक्स सबसिस्टम नहीं लिख रहे हैं, तब कौन परवाह करता है। आप win32 को लिख रहे होंगे।
• "प्रॉसेसक्रिएट के साथ कांटा की तुलना करना उचित नहीं है, क्योंकि वे अलग-अलग काम करते हैं, और विंडोज में कांटा नहीं है" - सच है, इसलिए मैं इस तरह की तुलना करूँगा। हालाँकि मैं कांटे की तुलना भी करूंगा, क्योंकि इसमें कई उपयोग के मामले हैं, जैसे कि प्रक्रिया अलगाव (जैसे वेब ब्राउज़र का प्रत्येक टैब एक अलग प्रक्रिया में चलता है)।

अब हम तथ्यों को देखते हैं, प्रदर्शन में अंतर क्या है?

Http://www.bitsnbites.eu/benchmarking-os-primatics/ से समर डेटा ।
क्योंकि पूर्वाग्रह अपरिहार्य है, जब संक्षेप में, मैंने इसे एमएस-विंडोज हार्डवेयर के पक्ष में किया था
अधिकांश परीक्षणों के लिए i7 8 कोर 3.2GHz। रास्पबेरी-पी को छोड़कर ग्नू / लिनक्स चल रहा है

नोट्स: लिनक्स पर, forkएमएस-विंडो का पसंदीदा तरीका तेज है CreateThread।

प्रक्रिया निर्माण प्रकार के संचालन के लिए नंबर (क्योंकि यह चार्ट में लिनक्स के लिए मूल्य देखना मुश्किल है)।

गति के क्रम में, सबसे तेज़ से धीमी गति से (संख्या समय है, छोटा बेहतर है)।

• Linux CreateThread 12
• Mac CreateThread 15
• लिनक्स फोर्क 19
• Windows CreateThread 25
• Linux CreateProcess (कांटा + निष्पादित) 45
• मैक फोर्क 105
• Mac CreateProcess (कांटा + निष्पादित) 453
• रास्पबेरी-पाई क्रिएटप्रोसेस (कांटा + निष्पादन) 501
• विंडोज CreateProcess 787
• Windows CreateProcess वायरस स्कैनर 2850 के साथ
• विंडोज फोर्क (क्रिएटप्रोसेस + फिक्सअप के साथ अनुकरण) 2850 की तुलना में ग्रेटर

अन्य माप के लिए नंबर

• एक फ़ाइल बनाना।
  • लिनक्स 13
  • मैक 113
  • विंडोज 225
  • रास्पबेरी-पाई (धीमी एसडी कार्ड के साथ) 241
  • डिफेंडर और वायरस स्कैनर आदि के साथ विंडोज 12950
• स्मृति आवंटित करना
  • लिनक्स 79
  • विंडोज 93
  • मैक 152

Answer 9

इसके अलावा प्लस तथ्य यह है कि Win मशीन पर सबसे अधिक एंटीवायरस सॉफ़्टवेयर CreateProcess के दौरान किक करेगा ... यह आमतौर पर सबसे बड़ी मंदी है।

Comments

हाँ यह सबसे बड़ा है, लेकिन एकमात्र महत्वपूर्ण मंदी नहीं है।

— ctrl-alt-delor

Answer 10

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

Comments

मुझे उम्मीद है कि अधिक जटिल सुरक्षा मॉडल अधिक सुरक्षित होगा; लेकिन तथ्यों से अन्यथा पता चलता है।

— रेयान

SELinux भी एक बहुत ही जटिल सुरक्षा मॉडल है, और यह एक महत्वपूर्ण ओवरहेड को लागू नहीं करता हैfork()

— Spudd86

@ लाइरेन, सॉफ्टवेयर डिजाइन में (मेरे अनुभव में), अधिक जटिल बहुत मुश्किल से ही अधिक सुरक्षित का मतलब है।

— वुड्रो डगलस 15