धागे के बीच क्या संसाधन साझा किए जाते हैं?

264

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

थ्रेड्स समान मेमोरी साझा करते हैं, प्रक्रियाएं नहीं होती हैं। इसका उत्तर देने के बाद, साक्षात्कारकर्ता ने मुझे एक बुरी मुस्कान दी और मुझ पर निम्नलिखित प्रश्न दागे:

Q. क्या आप उन सेगमेंट को जानते हैं जिनमें कोई प्रोग्राम विभाजित हो जाता है?

मेरा जवाब: हां (सोचा था कि यह एक आसान था) स्टैक, डेटा, कोड, हीप

Q. तो, मुझे बताओ: कौन से सेगमेंट थ्रेड साझा करते हैं?

मैं इसका जवाब नहीं दे सका और उन सभी को कहने में समाप्त हो गया।

कृपया, क्या कोई प्रक्रिया और धागे के बीच अंतर के लिए सही और प्रभावशाली उत्तर प्रस्तुत कर सकता है?

multithreading process operating-system

— Xinus
स्रोत

9

थ्रेड्स एक ही वर्चुअल एड्रेस-स्पेस साझा करते हैं , प्रक्रिया नहीं।

— बेनोइट

2

एक प्रक्रिया और एक धागे के बीच अंतर क्या है के

— sashoalm

177

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

— ग्रेग हेविल
स्रोत

27

दिलचस्प हिस्सा यह है कि भले ही थ्रेड्स में स्वतंत्र कॉल स्टैक हैं, अन्य स्टैक में मेमोरी अभी भी सुलभ है।

— कार्तिक बालगुरु

1

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

— bph

2

@ बीएफ: एक और धागे की स्टैक मेमोरी तक पहुंच संभव है, लेकिन अच्छे सॉफ्टवेयर इंजीनियरिंग अभ्यास के हितों में, मैं यह नहीं कहूंगा कि ऐसा करना स्वीकार्य है।

— ग्रेग हेविगिल

1

एक्सेस करना, विशेष रूप से लिखना, अन्य थ्रेड्स के ढेर कई कचरा कलेक्टर कार्यान्वयन के साथ गड़बड़ करते हैं। यह जीसी कार्यान्वयन की गलती के रूप में उचित ठहराया जा सकता है, हालांकि।

— yyny

56

से विकिपीडिया (मुझे लगता है कि साक्षात्कारकर्ता के लिए एक बहुत अच्छी जवाब होगा: पी)

उस में पारंपरिक मल्टीटास्किंग ऑपरेटिंग सिस्टम प्रक्रियाओं से थ्रेड्स भिन्न होते हैं:

प्रक्रियाएं आमतौर पर स्वतंत्र होती हैं, जबकि थ्रेड्स एक प्रक्रिया के सबसेट के रूप में मौजूद होते हैं

प्रक्रिया काफी राज्य की जानकारी लेती है, जबकि एक प्रक्रिया के भीतर कई धागे राज्य के साथ-साथ स्मृति और अन्य संसाधनों को साझा करते हैं

प्रक्रियाओं में अलग-अलग पता स्थान होते हैं, जबकि थ्रेड्स अपना पता स्थान साझा करते हैं

प्रक्रिया केवल सिस्टम द्वारा प्रदान की गई अंतर-प्रक्रिया संचार तंत्र के माध्यम से बातचीत करती है।

एक ही प्रक्रिया में थ्रेड के बीच स्विच करने का संदर्भ आमतौर पर प्रक्रियाओं के बीच संदर्भ स्विचिंग से अधिक तेज होता है।

— जॉर्ज कॉर्डोबा
स्रोत

2

ऊपर बिंदु 2 के बारे में: थ्रेड्स के लिए भी सीपीयू एक संदर्भ रखता है।

— जैक

49

कुछ ऐसा है जो वास्तव में इंगित करने की आवश्यकता है कि इस प्रश्न के दो पहलू हैं - सैद्धांतिक पहलू और कार्यान्वयन पहलू।

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

हम अनुभाग से निम्नलिखित है 2.2.2 शास्त्रीय थ्रेड मॉडल में आधुनिक ऑपरेटिंग सिस्टम 3E Tanenbaum द्वारा:

प्रक्रिया मॉडल दो स्वतंत्र अवधारणाओं पर आधारित है: संसाधन समूह और निष्पादन। कभी-कभी उन्हें अलग करना उपयोगी होता है; यह वह जगह है जहाँ धागे आते हैं ...

वह जारी है:

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

इसके अलावा, वह निम्नलिखित तालिका प्रदान करता है:

Per process items             | Per thread items
------------------------------|-----------------
Address space                 | Program counter
Global variables              | Registers
Open files                    | Stack
Child processes               | State
Pending alarms                |
Signals and signal handlers   |
Accounting information        |

ऊपर आपको काम करने के लिए थ्रेड्स की आवश्यकता है। जैसा कि अन्य ने बताया है, सेगमेंट जैसी चीजें ओएस पर निर्भर कार्यान्वयन विवरण हैं।

— रॉबर्ट एस। बार्न्स
स्रोत

2

यह एक महान व्याख्या है। लेकिन यह शायद किसी भी सवाल का जवाब किसी "जवाब" के रूप में दिया जाना चाहिए

— उत्प्रेरक

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

— onlycparra

29

साक्षात्कारकर्ता को बताएं कि यह पूरी तरह से ओएस के कार्यान्वयन पर निर्भर करता है।

उदाहरण के लिए विंडोज x86 को लें। केवल 2 खंड हैं [1], कोड और डेटा। और वे दोनों पूरे 2GB (रैखिक, उपयोगकर्ता) पता स्थान के लिए मैप किए गए हैं। आधार = 0, सीमा = 2GB। उन्होंने एक बना दिया होगा, लेकिन x86 किसी सेगमेंट को रीड / राइट और एक्सेक्यूट दोनों नहीं होने देता। इसलिए उन्होंने दो को बनाया, और कोड डिस्क्रिप्टर को इंगित करने के लिए सीएस सेट किया, और बाकी (डीएस, ईएस, एसएस, आदि) अन्य [2] को इंगित करने के लिए। लेकिन दोनों एक ही सामान की ओर इशारा करते हैं!

आपका साक्षात्कार करने वाले व्यक्ति ने एक छिपी हुई धारणा बनाई थी कि वह / वह राज्य नहीं करता है, और यह खींचने के लिए एक बेवकूफ चाल है।

तो संबंध है

Q. तो मुझे बताएं कि कौन सा सेगमेंट थ्रेड शेयर है?

सेगमेंट प्रश्न के लिए अप्रासंगिक हैं, कम से कम विंडोज पर। थ्रेड्स पूरे पते की जगह साझा करते हैं। केवल 1 स्टैक सेगमेंट है, एसएस, और यह उसी सामान को इंगित करता है जो डीएस, ईएस, और सीएस करते हैं [2]। यानी पूरी खूनी यूजर स्पेस । 0-2GB। बेशक, इसका मतलब यह नहीं है कि धागे केवल 1 स्टैक है। स्वाभाविक रूप से प्रत्येक का अपना स्टैक है, लेकिन x86 खंडों का उपयोग इस उद्देश्य के लिए नहीं किया जाता है।

शायद * nix कुछ अलग करता है। कौन जाने। प्रश्न जिस आधार पर था, वह टूट गया था।

कम से कम यूजर स्पेस के लिए।
से ntsd notepad:cs=001b ss=0023 ds=0023 es=0023

— एलेक्स बुडोव्स्की
स्रोत

1

हां ... सेगमेंट OS और कंपाइलर / लिंकर पर निर्भर करता है। कभी-कभी DATA खंड से अलग BSS खंड होता है। कभी-कभी RODATA होता है (लगातार स्ट्रिंग की तरह डेटा जो केवल पढ़ने के लिए चिह्नित पृष्ठों में हो सकता है)। कुछ सिस्टम DATA को SMALL DATA (एक आधार + 16-बिट ऑफ़सेट से सुलभ) और (FAR) DATA (32-बिट ऑफ़सेट एक्सेस के लिए आवश्यक) में तोड़ते हैं। यह भी संभव है कि एक अतिरिक्त TLS DATA (थ्रेड लोकल स्टोर) सेगमेंट है जो प्रति-थ्रेड आधार पर उत्पन्न होता है

— Adisak

5

आह, नहीं! आप खंडों के साथ खंडों को भ्रमित कर रहे हैं! अनुभाग हैं कि लिंकर ने मॉड्यूल को भागों में विभाजित किया है (डेटा, rdata, पाठ, bss, आदि ..) जैसा कि आपने वर्णित किया है। लेकिन मैं सेगमेंट के बारे में बात कर रहा हूं, जैसा कि इंटेल / एएमडी x86 हार्डवेयर में निर्दिष्ट है। संकलक / लिंकर से संबंधित नहीं है। आशा है कि समझ में आता है।

— एलेक्स बुडोव्स्की

हालाँकि, Adisak थ्रेड लोकल स्टोर के बारे में सही है। यह थ्रेड के लिए निजी है और साझा नहीं किया गया है। मैं विंडोज ओएस से अवगत हूं और अन्य ओएस के बारे में सुनिश्चित नहीं हूं।

— जैक

20

आमतौर पर, थ्रेड्स को हल्के वजन की प्रक्रिया कहा जाता है। यदि हम मेमोरी को तीन खंडों में विभाजित करते हैं तो यह होगा: कोड, डेटा और स्टैक। हर प्रक्रिया का अपना कोड, डेटा और स्टैक सेक्शन होता है और इस संदर्भ के कारण स्विच का समय थोड़ा अधिक होता है। संदर्भ स्विचिंग समय को कम करने के लिए, लोग थ्रेड की अवधारणा के साथ आए हैं, जो डेटा और कोड सेगमेंट को अन्य थ्रेड / प्रक्रिया के साथ साझा करता है और इसका अपना STACK खंड है।

— निमिष ठक्कर
स्रोत

तुम ढेर भूल गए। हीप, अगर मैं गलत नहीं हूं, तो थ्रेड्स के बीच साझा किया जाना चाहिए

— Phate

20

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

— धीरेंद्र विकाश शर्मा
स्रोत

13

थ्रेड्स कोड और डेटा खंड और हीप साझा करते हैं, लेकिन वे स्टैक साझा नहीं करते हैं।

— केविन पीटरसन
स्रोत

11

"स्टैक में डेटा तक पहुंचने में सक्षम" और स्टैक को साझा करने के बीच अंतर है। उन थ्रेड्स के अपने स्वयं के ढेर होते हैं जो पुश और पॉप अप करते हैं जब वे तरीकों को कॉल करते हैं।

— केविन पीटरसन

2

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

— डेविड श्वार्ट्ज

@DavidSchwartz, क्या मैं आपकी बात को नीचे के रूप में संक्षेप में प्रस्तुत कर सकता हूं: हर धागे का अपना ढेर होता है, और स्टैक में 2 भाग होते हैं - पहला भाग जो थ्रेड्स के बीच साझा किया जाता है प्रक्रिया से पहले बहु-थ्रेडेड है, और दूसरा भाग जो पॉप्युलेट होता है मालिक का धागा चल रहा है .. सहमत?

— फेसब्रो

2

@nextTide दो भाग नहीं हैं। ढेर साझा किए जाते हैं, अवधि। प्रत्येक थ्रेड का अपना स्टैक होता है, लेकिन वे भी साझा किए जाते हैं। शायद एक अच्छा सादृश्य यह है कि यदि आप हैं और आपकी पत्नी के पास प्रत्येक कार है, लेकिन आप एक-दूसरे की कारों का उपयोग किसी भी समय कर सकते हैं।

— डेविड श्वार्ट्ज

5

थ्रेड्स डेटा और कोड साझा करते हैं जबकि प्रक्रियाएं नहीं करती हैं। स्टैक दोनों के लिए साझा नहीं किया गया है।

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

           प्रक्रिया थ्रेड

   ढेर निजी
   डेटा निजी साझा किया गया
   कोड निजी ¹   साझा ²

¹ कोड तार्किक रूप से निजी है, लेकिन प्रदर्शन कारणों से साझा किया जा सकता है। ² मुझे 100% यकीन नहीं है।

— डैनियल ब्रुकनर
स्रोत

मैं कहता हूं कि कोड खंड (टेक्स्ट सेगमेंट), डेटा के विपरीत, लगभग हमेशा अधिकांश आर्किटेक्चर पर आसानी से पढ़ा जाता है।

— जॉर्ज कॉर्डोबा

4

धागे सब कुछ साझा करते हैं [1]। पूरी प्रक्रिया के लिए एक पता स्थान है।

प्रत्येक थ्रेड का अपना स्टैक और रजिस्टर होता है, लेकिन साझा पता स्थान में सभी थ्रेड्स के ढेर दिखाई देते हैं।

यदि एक थ्रेड अपने स्टैक पर कुछ ऑब्जेक्ट आवंटित करता है, और दूसरे थ्रेड को पता भेजता है, तो वे दोनों उस वस्तु तक समान पहुंच प्राप्त करेंगे।

दरअसल, मैंने अभी एक व्यापक मुद्दे पर ध्यान दिया है: मुझे लगता है कि आप शब्द खंड के दो उपयोगों को भ्रमित कर रहे हैं ।

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

इन बाइनरी फ़ाइल सेगमेंट को अलग-अलग अनुमतियों (जैसे, कोड / टेक्स्ट के लिए केवल-पढ़ने योग्य निष्पादन योग्य, और प्रारंभिक डेटा के लिए गैर-निष्पादन योग्य लिखने) के साथ, प्रक्रिया पता स्थान में मैप किया जा सकता है।

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

[१] ठीक है, मुझे पता है: सिग्नल मास्क, टीएसएस / टीएसडी आदि। इसके सभी मैप किए गए प्रोग्राम सेगमेंट सहित पता स्थान अभी भी साझा किए जाते हैं।

— निकम्मा
स्रोत

3

एक x86 ढांचे में, कोई भी कई खंडों को विभाजित कर सकता है (2 ^ 16-1 तक)। ASM निर्देशन सेगमेंट / ENDS इसकी अनुमति देता है, और ऑपरेटर SEG और OFFSET सेगमेंट रजिस्टरों के आरंभ की अनुमति देता है। सीएस: आईपी आमतौर पर लोडर द्वारा आरंभीकृत किया जाता है, लेकिन डीएस, ईएस, एसएस के लिए आवेदन आरंभीकरण के साथ जिम्मेदार है। कई वातावरण तथाकथित "सरलीकृत खंड परिभाषाओं" जैसे .code, .data, .bs, .stack आदि की अनुमति देते हैं और, "मेमोरी मॉडल" (छोटे, बड़े, कॉम्पैक्ट आदि) के आधार पर लोडर सेगमेंट रजिस्टरों को आरंभ करता है। तदनुसार। आम तौर पर .data, .bs, .stack और अन्य सामान्य खंड (मैंने 20 साल से ऐसा नहीं किया है, इसलिए मुझे याद नहीं है) एक ही समूह में बांटे गए हैं - यही कारण है कि आमतौर पर डीएस, ईएस और एसएस को अंक मिलते हैं। एक ही क्षेत्र, लेकिन यह केवल चीजों को सरल बनाने के लिए है।

सामान्य तौर पर, सभी सेगमेंट रजिस्टर में रन-टाइम पर अलग-अलग मूल्य हो सकते हैं। इसलिए, साक्षात्कार प्रश्न सही था: थ्रेड्स के बीच CODE, DATA और STACK में से एक साझा किया गया है। हीप प्रबंधन कुछ और है - यह केवल ओएस पर कॉल का एक क्रम है। लेकिन क्या होगा अगर आपके पास एक ओएस नहीं है, जैसे कि एक एम्बेडेड सिस्टम - क्या आप अभी भी अपने कोड में नए / हटा सकते हैं?

युवा लोगों को मेरी सलाह - कुछ अच्छी विधानसभा प्रोग्रामिंग पुस्तक पढ़ें। ऐसा लगता है कि इस संबंध में विश्वविद्यालय के पाठ्यक्रम काफी खराब हैं।

— जॉर्ज
स्रोत

2

वैश्विक मेमोरी के अलावा, थ्रेड्स कई अन्य विशेषताओं को भी साझा करते हैं (यानी, ये विशेषताएँ एक थ्रेड के लिए विशिष्ट होने के बजाय एक प्रक्रिया के लिए वैश्विक हैं)। इन विशेषताओं में निम्नलिखित शामिल हैं:

प्रक्रिया आईडी और मूल प्रक्रिया आईडी;

प्रक्रिया समूह आईडी और सत्र आईडी;

टर्मिनल को नियंत्रित करना;

प्रक्रिया क्रेडेंशियल्स (उपयोगकर्ता और समूह आईडी);

खुली फ़ाइल विवरणक;

रिकॉर्ड ताले का उपयोग कर बनाया fcntl();

संकेत निपटान;

फ़ाइल सिस्टम से संबंधित जानकारी: umask, वर्तमान कार्यशील निर्देशिका, और रूट निर्देशिका;

अंतराल टाइमर ( setitimer()) और POSIX टाइमर ( timer_create());

सिस्टम वी सेमाफोर पूर्ववत ( semadj) मान (धारा 47.8);

संसाधन सीमा;

सीपीयू समय खपत (के रूप में द्वारा लौटा times());

भस्म किए गए संसाधन (जैसा कि लौटा दिया गया है getrusage()); तथा

अच्छा मूल्य (द्वारा निर्धारित setpriority()और nice())।

प्रत्येक थ्रेड के लिए अलग-अलग विशेषताएँ निम्नलिखित हैं:

थ्रेड आईडी (धारा 29.5);

संकेत मुखौटा;

थ्रेड-विशिष्ट डेटा (धारा 31.3);

वैकल्पिक संकेत स्टैक ( sigaltstack());

गलत चर;

फ्लोटिंग-पॉइंट पर्यावरण (देखें fenv(3));

रीयलटाइम निर्धारण नीति और प्राथमिकता (धारा 35.2 और 35.3);

सीपीयू आत्मीयता (लिनक्स-विशिष्ट, धारा 35.4 में वर्णित);

क्षमताओं (लिनक्स-विशिष्ट, अध्याय 39 में वर्णित); तथा

स्टैक (स्थानीय चर और फ़ंक्शन कॉल लिंकेज जानकारी)।

इसके अंश: लिनक्स प्रोग्रामिंग इंटरफ़ेस: एक लिनक्स और यूनिक्स सिस्टम प्रोग्रामिंग हैंडबुक, माइकल केरिसक , पृष्ठ 3 919

— SNR
स्रोत

0

थ्रेड शेयर हीप (थ्रेड विशिष्ट ढेर के बारे में एक शोध है) लेकिन वर्तमान कार्यान्वयन ढेर को साझा करते हैं। (और निश्चित रूप से कोड)

— दानी
स्रोत

0

प्रक्रिया में सभी थ्रेड्स सिस्टम संसाधन जैसे हीप मेमोरी आदि साझा करते हैं जबकि थ्रेड का अपना स्टैक होता है

तो आपका ans ढेर मेमोरी होना चाहिए जो सभी थ्रेड्स एक प्रक्रिया के लिए साझा करते हैं।

— रोशनी
स्रोत