कर्नेल धागे और उपयोगकर्ता धागे के बीच क्या अंतर है?

Question

कर्नेल धागे और उपयोगकर्ता धागे के बीच क्या अंतर है? क्या यह कर्नेल थ्रेड को कर्नेल मोड में निर्धारित और निष्पादित किया गया है? कर्नेल धागे बनाने के लिए उपयोग की जाने वाली तकनीकें क्या हैं?

क्या यह उपयोगकर्ता थ्रेड निर्धारित है, उपयोगकर्ता मोड में निष्पादित किया गया है? क्या यह है कि कर्नेल उपयोगकर्ता थ्रेड निष्पादित/शेड्यूल करने में भाग नहीं लेता है? जब उपयोगकर्ता थ्रेड निष्पादित करने में बाधा उत्पन्न होती है तो कौन इसे संभालता है?

जब भी, थ्रेड बनाया जाता है तो प्रत्येक के लिए टीसीबी बनाया जाता है। अब उपयोगकर्ता स्तर के धागे के मामले में यह है कि यह टीसीबी उपयोगकर्ता के पता स्थान में बनाया गया है?

संदर्भ स्विचिंग को संभालने वाले दो उपयोगकर्ता स्तर धागे के बीच स्विच करने के मामले में?

1. कई एक के बाद एक
2. कई कई करने के लिए
3. एक करने के लिए:

   multithreading मॉडलों में से एक अवधारणा है।

ये मॉडल क्या हैं? इन मॉडलों का व्यावहारिक रूप से उपयोग कैसे किया जाता है?

इस विषय पर कुछ लेख पढ़ा है, लेकिन अभी भी
अवधारणा स्पष्ट करने के लिए चाहता है उलझन में ..

अग्रिम धन्यवाद, Tazim

Answer 1

कर्नेल धागे और उपयोगकर्ता धागे के बीच क्या अंतर है?

कर्नेल धागे विशेषाधिकार प्राप्त हैं और उपयोगकर्ता मोड थ्रेड के लिए ऑफ-सीमा तक पहुंच सकते हैं। विकिपीडिया पर "Ring (Computer Security)" पर एक नज़र डालें। विंडोज़ पर, उपयोगकर्ता मोड रिंग 3 से मेल खाता है, जबकि कर्नेल मोड रिंग 0 से मेल खाता है।

कर्नेल धागे बनाने के लिए तकनीक का उपयोग क्या किया जाता है?

यह ऑपरेटिंग सिस्टम पर बेहद निर्भर है।

अब उपयोगकर्ता स्तर के धागे के मामले में यह है कि यह टीसीबी उपयोगकर्ता के पता स्थान में बनाया गया है?

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

ये मॉडल क्या हैं? इन मॉडलों का व्यावहारिक रूप से उपयोग कैसे किया जाता है?

Wikipedia इसके बारे में वास्तव में स्पष्ट लगता है।

Answer 2

विकिपीडिया सबसे के जवाब इन सवालों के सभी नहीं तो नहीं है।

http://en.wikipedia.org/wiki/Thread_(computer_science)

http://en.wikipedia.org/wiki/Thread_(computer_science)#Processes.2C_kernel_threads.2C_user_threads.2C_and_fibers

Answer 3

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

Answer 4

कर्नेल थ्रेड का अर्थ है कि कर्नेल शेड्यूलिंग के लिए ज़िम्मेदार है। इसका मतलब यह है कि, अन्य चीजों के साथ, कर्नेल एक ही समय में प्रत्येक थ्रेड को अलग-अलग सीपीयू/कोर पर शेड्यूल करने में सक्षम है।

उन्हें कैसे उपयोग करने के लिए प्रोग्रामिंग भाषाओं और सूत्रण API के साथ एक बहुत भिन्न है, लेकिन एक सरल उदाहरण,

void task_a(); 
void task_b(); 
int main() { 
    new_thread(task_a); 
    new_thread(task_b); 
    // possibly do something else in the main thread 
    // wait for the threads to complete their work 
} 

हर कार्यान्वयन मैं से परिचित हूँ के रूप में, कर्नेल उन्हें किसी भी समय रोक सकते हैं। ("पूर्व-खाली")

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

एक तरफ आपके पास "ग्रीन थ्रेड" है; मूल रूप से कर्नेल धागे के समान काम करने की कोशिश कर रहा है। इस प्रकार आप वास्तविक धागे के साथ प्रोग्रामिंग की सभी जटिलताओं को रखते हैं।

विपरीत अंत में, आपके पास "फाइबर" हैं, जिन्हें किसी भी अन्य फाइबर चलाने से पहले उपज करने की आवश्यकता होती है। इसका मतलब है

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

फाइबर की सबसे सरल उदाहरण मैं के बारे में सोच सकते हैं:

while(tasks_not_done) { 
    do_part_of_a(); 
    do_part_of_b(); 
} 

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