मैं प्रसिद्ध भोजन दार्शनिकों पर काम करने की कोशिश कर रहा हूं और यह काफी समाप्त हो गया है लेकिन मुझे धागे को बाधित करने में काफी कठिन समय हो रहा है।

इसलिए जैसा कि आप जानते हैं कि इस समस्या में हमारे पास 5 सूत्र (दार्शनिक) हैं और उपयोगकर्ता एक प्रयोग समय निर्धारित करता है जिस पर प्रयोग समाप्त हो जाएगा।

ध्यान देने योग्य बात यह है कि मैंने StackOverflow पर कई उत्तर देखे।

पहला @Konrad Reiche आप जावा में एक थ्रेड को कैसे मारते हैं? /स्टैकओवरफ्लो लिंक

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

दूसरा है थ्रेड इंटरप्ट () थ्रेड/स्टैकओवरफ्लो लिंक को बाधित नहीं करता है

अभी तक वास्तव में कुछ भी मदद नहीं की!

मैं आवश्यक कोड प्रदान करने का प्रयास करूंगा और मुझे आशा है कि कोई मेरी गलती को इंगित करेगा। दार्शनिक वर्ग सार्वजनिक है और थ्रेड का विस्तार करता है!

1) पहला प्रयास: (प्रोफेसर द्वारा अस्वीकार कर दिया जा सकता है यदि वह नहीं चाहता कि हम अस्थिर बूलियन को ध्वज के रूप में उपयोग करें!)

इस तरह अस्थिर बूलियन का उपयोग करते समय यह काम करता है:

private volatile boolean isNotStopped=true;

@Override
public void stopPhilosopher() {
    System.out.printf("\n%s will stop.\n",selfPhilosopher.getName());
    selfPhilosopher.interrupt();
    isNotStopped=false;
}


@Override
public void run() {
    while (isNotStopped){//selfPhilosopher is a thread equals to this!.
        try {
                think();
                eat();
        } catch (InterruptedException e) {//somehow this was never triggered!.
            System.out.printf("%s was interrupted.\n",selfPhilosopher.getName());
        }finally {//in the finally block i always get RUNNER, FALSE
            System.out.printf("the %s is %s and is interrupted %b.\n", selfPhilosopher.getName(),selfPhilosopher.getState(), selfPhilosopher.isInterrupted());
        }
    }
}

[अद्यतन] दूसरे प्रयास पर:[काम कर रहे]

selfPhilosopher.isInterrupted() को Thread.currentThread().isInterrupted() से बदलने से कोई फर्क नहीं पड़ा क्योंकि selfPhilosopher=this;

फिर भी मुझे stopPhilosopher() विधि से "बंद हो जाएगा" मिल रहा था, लेकिन धागे ऐसे प्रतीत होते हैं जैसे लाश जीवन में वापस आती रहती है :(

इस तथ्य के कारण कि मैं @Konrad Reiche की पहली संदर्भ की राय से काफी आश्वस्त हूं और इसका उत्तर दिया गया है @ नाथन ह्यूजेस मैं एक अस्थिर ध्वज का उपयोग करने के बजाय जावा isInterrupted() द्वारा प्रदान किए गए बूलियन ध्वज का उपयोग करने के साथ रहूंगा।

@Override
public void stopPhilosopher() {
    System.out.printf("\n%s will stop.\n",selfPhilosopher.getName());
    selfPhilosopher.interrupt();

}

@Override
public void run() {
    while (!selfPhilosopher.isInterrupted()){//selfPhilosopher is a thread equals to this!.
        try {
                think();
                eat();
        } catch (InterruptedException e) {//somehow this was never triggered!.Now it works.
            System.out.printf("%s was interrupted from catch clause!..\n",selfPhilosopher.getName());
            selfPhilosopher.interrupt();
        }
    }
}

आउटपुट:

 Philosopher2 in seat nr: 2 was interrupted from catch clause!..
1
StudentAccount4 3 अप्रैल 2020, 01:08
"थ्रेड न तो समाप्त होगा और न ही बाधित होगा" - क्या आप कह रहे हैं कि आपने अपने पहले प्रयास में "{name} बाधित हुआ" संदेश कभी नहीं देखा?
 – 
Joni
3 अप्रैल 2020, 01:16
नहीं पकड़ खंड बिल्कुल ट्रिगर नहीं होगा। मैं केवल अंत में ब्लॉक देखता हूं जो नाम और एक रनर राज्य को FALSE के साथ प्रिंट करेगा
 – 
StudentAccount4
3 अप्रैल 2020, 01:20

2 जवाब

सबसे बढ़िया उत्तर

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

इसका वर्णन स्लीप विधि के लिए API दस्तावेज़:

इंटरप्टेड एक्सेप्शन - यदि किसी थ्रेड ने वर्तमान थ्रेड को बाधित किया है। जब यह अपवाद फेंका जाता है तो वर्तमान थ्रेड की बाधित स्थिति साफ़ हो जाती है।

इस लाइन को उस ब्लॉक में जोड़ें जहां आप एक इंटरप्टेड एक्सेप्शन पकड़ते हैं:

Thread.currentThread().interrupt();  // restores interrupt flag
1
Nathan Hughes 3 अप्रैल 2020, 01:13
सबसे पहले मदद के लिए धन्यवाद। महोदय, जैसा कि कोड में लिखा गया है, रन विधि के कैच क्लॉज में कैच ब्लॉक किसी तरह कभी ट्रिगर नहीं होता है। तो क्या आप मुझे बताएंगे कि इससे क्या फायदा होगा?!
 – 
StudentAccount4
3 अप्रैल 2020, 01:18
@ छात्र खाता 4: यदि आप नींद नहीं कहते हैं तो इंटरप्टेड एक्सेप्शन फेंका नहीं जाएगा। ओह, आपको एक और त्रुटि है।
 – 
Nathan Hughes
3 अप्रैल 2020, 01:19
@ studentaccount4: परीक्षण !selfPhilosopher.isInterrupted() को !Thread.currentThread().isInterrupted() में बदलने का प्रयास करें, क्या आप सुनिश्चित हैं कि पोस्ट किया गया कोड समस्या को पुन: उत्पन्न करता है?
 – 
Nathan Hughes
3 अप्रैल 2020, 01:23
यह पता चला कि क्लचिंग के कारण कोई अन्य त्रुटि हो रही थी। लेकिन क्या आप कृपया मुझे पोस्ट के अंत में दो प्रश्नों के बारे में कुछ छोटे उत्तर प्रदान करने का प्रयास करेंगे। अग्रिम में धन्यवाद। :)
 – 
StudentAccount4
3 अप्रैल 2020, 02:05

सबसे पहले: मैं isInterrupted() के ऊपर अस्थिर बूलियन ध्वज का समर्थन करता हूं। यह स्पष्ट, संक्षिप्त और मुहावरेदार रूप से स्थापित है। isInterrupted() के लिए आवश्यक संरचना विवरण पर अधिक निर्भर करती है (उदाहरण के लिए आपके मामले में कोशिश करें/पकड़ें क्योंकि ऐसा लगता है कि Thread.sleep (या कुछ समान) InterruptedException घोषित कर रहा है)।

चूँकि आपके उदाहरण में InterruptedException try/catch InterruptedException समय-समय पर इंटरप्ट का उपभोग किया जाता है और selfPhilosopher (जो थोड़ा संदिग्ध लगता है) को फिर से भेजने की आवश्यकता है। इससे बचने के लिए आस-पास की कोशिश-पकड़ में लूप डालें:

try {
    while (!selfPhilosopher.isInterrupted()) {
        think();
        eat();
    } 
} catch (InterruptedException e) {
    System.out.printf("%s was interrupted from catch clause!..\n",selfPhilosopher.getName());
    // not necessary anymore: selfPhilosopher.interrupt();
}

अस्थिर बूलियन ध्वज को फिर से भेजने की आवश्यकता नहीं होगी और दोनों नक्षत्रों में उपयोग किया जा सकता है (जबकि आसपास के प्रयास/पकड़ के साथ-साथ प्रयास के दौरान)।

इसके अतिरिक्त: मान लीजिए कि आपकी कक्षा Runnable लागू करती है और Thread का विस्तार नहीं कर रही है, तो आपको run (और कहीं नहीं) की शुरुआत में selfPhilosopher सेटिंग का ध्यान रखना होगा।

1
tastaturtier 2 मई 2020, 22:25
मैंने अभी देखा। इस प्रोफेसर को लिखने के लिए समय निकालने के लिए धन्यवाद :)। खुशी है कि आपने फाइल में संलग्न लिंक को देखा :)
 – 
StudentAccount4
30 जून 2020, 20:03