में डेडलॉक पढ़ें कि एक थ्रेड किए गए जावा प्रोग्राम में डेडलॉक हो सकता है। मैं सोच रहा हूं कि कैसे बाद में कोई प्रतिस्पर्धा नहीं होगी। जहां तक मुझे याद है, किताबें एक से अधिक धागे के साथ उदाहरणों को चित्रित करती हैं। यदि आप एक धागे से हो सकते हैं तो क्या आप एक उदाहरण दे सकते हैं।एक थ्रेडेड जावा प्रोग्राम
सं
डेडलॉक से अधिक थ्रेड (या प्रक्रियाओं) इस तरह से है कि न तो जारी रख सकते हैं में ताले प्राप्त करने के लिए प्रयास के परिणामस्वरूप है।
विकिपीडिया लेख से एक उद्धरण पर विचार करें: "। दो गाड़ियों एक क्रॉसिंग पर एक दूसरे के दृष्टिकोण, दोनों एक पूर्ण विराम करने के लिए आ जाएगा और जब तक अन्य चला गया है न फिर से शुरू करेगा" (http://en.wikipedia.org/wiki/Deadlock)
नहीं, मेरे लिए बहुत असंभव लगता है।
लेकिन आप सैद्धांतिक रूप से सिस्टम संसाधन को लॉक कर सकते हैं जबकि एक अन्य ऐप किसी दूसरे को लॉक कर देता है जिसे आप अनुरोध करने जा रहे हैं और वह ऐप आपके द्वारा पहले से लॉक किए गए अनुरोध का अनुरोध करेगा। बैंग डेडलॉक।
लेकिन ओएस उस चीज़ को पहचानकर इस प्रक्रिया को हल करने में सक्षम होना चाहिए और उस समय दोनों संसाधनों को एक ऐप को देना चाहिए। ऐसा होने की संभावना किसी के लिए पतली नहीं है, लेकिन कोई भी अच्छा ओएस इस अरबों मौके को संभालने में सक्षम होना चाहिए।
यदि आप डिजाइन को ध्यान से बनाते हैं और केवल एक ही समय में एक संसाधन को लॉक करते हैं, तो ऐसा नहीं हो सकता है।
डाउनवोट क्यों? यह उत्तर एक ऐसी बात पर सटीक चर्चा कर रहा है जो एक अरब में हो सकता है। – Frank
मैंने आपको वोट नहीं दिया, लेकिन मैंने लगभग किया। आपका दूसरा पैराग्राफ सही है, इसलिए इस घटना का डिज़ाइन आपके द्वारा वर्णित तरीके से संचालित होने पर होने का मौका बहुत अधिक होता है। तो आपका तीसरा पैरा _wrong_ है (अधिकांश ओएस पर अधिकांश संसाधनों के लिए)। आखिरकार, ** ओएस डेडलॉक से बचने के लिए बिल्कुल क्या करेगा? ** – NVRAM
और आपका तीसरा अनुच्छेद यह मानता है कि ऐप केवल एक ही संसाधन के साथ अपने लक्ष्यों को पूरा कर सकता है, जो कि बड़ी संख्या में समस्याओं के लिए काम नहीं करता है। – NVRAM
यह एक बात है कि आप "डेडलॉक" को कैसे परिभाषित करते हैं।
उदाहरण के लिए, यह परिदृश्य कुछ यथार्थवादी है: एक एकल-थ्रेडेड एप्लिकेशन जो आकार-सीमित कतार का उपयोग करता है जो इसकी सीमा तक पहुंचने पर अवरुद्ध होता है। जब तक सीमा तक नहीं पहुंच जाती है, यह एक धागे के साथ ठीक काम करेगा। लेकिन जब सीमा तक पहुंच जाती है, तो थ्रेड कतार से कुछ लेने के लिए हमेशा के लिए एक (गैर-मौजूदा) अन्य धागे के लिए इंतजार करेगा ताकि वह जारी रख सके।
खैर मैं हाँ कहने
आप लगातार एक ही धागे के भीतर एक ही ताला प्राप्त करने के लिए प्रयास करते हैं तो हिम्मत, यह लॉक या कार्यान्वयन पर ताला लगा है कि क्या यह जाँच करता है ताला एक ही धागा ने अधिग्रहण कर लिया जाता है, तो के प्रकार पर निर्भर करता है। यदि कार्यान्वयन यह जांच नहीं करता है, तो आपके पास डेडलॉक है।
सिंक्रनाइज़ करने के लिए यह चेक किया गया है, लेकिन मुझे सेमफोर की गारंटी नहीं मिली।
यदि आप किसी अन्य प्रकार के लॉक का उपयोग करते हैं, तो आपको यह जांचना होगा कि यह व्यवहार करने की गारंटी कैसे है!
जैसा कि पहले से ही बताया गया है, आप प्रतिबंधित बफर को पढ़ने/लिखकर ब्लॉक कर सकते हैं (जो डेडलॉक से अलग है)। उदाहरण के लिए आप चीजों को एक स्लॉट बफर में लिखते हैं और केवल कुछ शर्तों पर इसे पढ़ते हैं। जब आप अब सम्मिलित नहीं कर सकते हैं, तब तक आप एक स्लॉट मुक्त होने तक प्रतीक्षा करते हैं, जो तब नहीं होगा जब आप स्वयं पढ़ते हैं।
तो मुझे डर है कि जवाब हाँ होना चाहिए, हालांकि यह इतना आसान और आमतौर पर पता लगाना आसान नहीं है।
hth
मारियो
पहले मल्टीकोर प्रोसेसर सस्ता हो गया, सभी डेस्कटॉप कंप्यूटर सिंगल-कोर प्रोसेसर था। सिंगल-कोर प्रोसेसर केवल धागे पर चलता है। तो फिर multithreading कैसे काम किया? जावा के लिए सबसे सरल कार्यान्वयन होगा:
thread1 के कोड:
doSomething();
yield(); // may switch to another thread
doSomethingElse();
thread2 के कोड:
doSomething2();
yield(); // may switch to another thread
doSomethingElse2();
इस सहकारी बहु सूत्रण कहा जाता है - सब सिर्फ 1 धागा साथ किया जाता है, और इसलिए बहु सूत्रण था विंडोज 3.1 में किया गया।
प्रीपेप्टिव मल्टीथ्रेडिंग नामक आज की मल्टीथ्रेडिंग सहकारी मल्टीथ्रेडिंग का मामूली संशोधन है जहां इस उपज() को समय-समय पर स्वचालित रूप से बुलाया जाता है।
सभी कि निम्नलिखित interlacings को कम कर सकते हैं:
doSomething();
doSomething2();
doSomethingElse2();
doSomethingElse();
या:
doSomething();
doSomething2();
doSomethingElse();
doSomethingElse2();
और इसी तरह ... हम एकल पिरोया कोड के लिए बहु-क्रम कोड बदल दिया। तो हाँ, यदि एकल-थ्रेड वाले मल्टीथ्रेड प्रोग्राम में डेडलॉक भी संभव है। उदाहरण के लिए:
thread1:
queue.put(x);
yield();
thread2:
x = queue.waitAndGet()
yield();
यह इस जिल्द के साथ ठीक है:
queue.put(x);
x = queue.waitAndGet()
लेकिन यहाँ पर हम पाते हैं गतिरोध:
x = queue.waitAndGet()
queue.put(x);
तो हां, सिंगल थ्रेडेड प्रोग्राम्स में डेडलॉक्स संभव हैं।
बहुत अच्छा बिंदु –
क्या वह डेडलॉक हर बार नहीं होगा? – Frank
उन 2 'धागे' और उपज() के साथ यह यादृच्छिक रूप से होगा, आधुनिक ऑपरेटिंग सिस्टम (जो कोई उपज() लेकिन प्रीपेप्टिव थ्रेडिंग का उपयोग नहीं करता है) यह दूसरे सिंगल-थ्रेडेड समाधान के साथ काम करेगा, डेडलॉक हर बार होता है, बस BlockingQueue से उचित तरीकों के साथ मेरी 'queue.xxxx()' विधियों को प्रतिस्थापित करें। धागा सोचता है कि यह किसी अन्य धागे के लिए इंतजार कर रहा है, जबकि यह अपने लिए इंतजार कर रहा है। :-) – iirekm
भले ही आपकी जावा सामग्री एकल-थ्रेडेड हो, फिर भी सिग्नल हैंडलर हैं, जिन्हें मुख्य धागे की तुलना में एक अलग थ्रेड/संदर्भ में निष्पादित किया जाता है।
तो, सिंगल-थ्रेडेड समाधानों पर भी एक डेडलॉक वास्तव में हो सकता है, अगर जावा लिनक्स पर चल रहा हो।
QED। -pbr
+1 सिग्नल के बारे में नहीं सोचा था! –
एकाधिक धागे या * प्रक्रिया * .... – NVRAM
अच्छा बिंदु कार्टर। मैंने अपनी टिप्पणी संपादित की है। धन्यवाद। – philipk
हां, ठीक है, एकाधिक (यानी 0 से अधिक) धागे, यही वह है जिसके बारे में हम बात कर रहे हैं। – Ingo