जावा में फ़ंक्शन कॉल को अवरुद्ध करने के लिए प्रतीक्षा कर रहे थ्रेड को कैसे मारना है?

Question

मैं एक धागा है:

Thread t = new Thread(){ 
    public void run(){ 
     ServerSocketConnection scn = (ServerSocketConnection) 
       Connector.open("socket://:1234"); 
     // Wait for a connection. 
     SocketConnection sc = (SocketConnection) scn.acceptAndOpen(); 
     //do other operation 
    } 
}; 
t.start(); 

चलें कहते हैं कि कोई ग्राहक सर्वर से कनेक्ट हो रहा है, तो यह धागा हो जाएगा blocked.Now मैं ऊपर धागा टी को मारने के लिए करना चाहते हैं? मैं इसे कैसे मार सकता हूँ?

Answer 1

Thread.interrupt() सॉकेट पर अवरुद्ध थ्रेड को बाधित नहीं करेगा। आप Thread.stop() या Thread.destroy() पर कॉल करने का प्रयास कर सकते हैं, लेकिन इन विधियों को बहिष्कृत कर दिया गया है (संपादित करें: वास्तव में, अनुपस्थित जे 2 एमई में) और कुछ मामलों में गैर-कार्यात्मक, कारणों से आप here पढ़ सकते हैं। जैसा कि लेख का उल्लेख है, आपके मामले में सबसे अच्छा समाधान उस सॉकेट को बंद करना है जिसे आप अवरुद्ध कर रहे हैं:

कुछ मामलों में, आप एप्लिकेशन विशिष्ट चाल का उपयोग कर सकते हैं। उदाहरण के लिए, यदि कोई ज्ञात ज्ञात सॉकेट पर थ्रेड इंतजार कर रहा है, तो थ्रेड को तत्काल लौटने के कारण आप सॉकेट बंद कर सकते हैं। दुर्भाग्य से, वास्तव में कोई तकनीक नहीं है जो सामान्य रूप से काम करती है। यह ध्यान दिया जाना चाहिए कि सभी परिस्थितियों में जहां एक प्रतीक्षा धागा Thread.interrupt का जवाब नहीं देता है, तो यह थ्रेड.स्टॉप को भी प्रतिसाद नहीं देगा। ऐसे मामलों में जानबूझकर इनकार करने वाले सेवा हमलों, और I/O संचालन शामिल हैं जिसके लिए thread.stop और thread.interrupt ठीक से काम नहीं करते हैं।

Answer 2

आप thread.interrupt() पर कॉल कर सकते हैं। यह आपके थ्रेड

Answer 3

पर Thread.interrupt() पर InterruptedException फेंक देगा। ब्लॉकिंग ऑपरेशंस आम तौर पर InterruptedException फेंक देते हैं यदि Thread वे निष्पादित कर रहे हैं तो बाधित है।

Answer 4

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

Answer 5

अपने मुख्य धागे (जब आप स्वीकृति-थ्रेड को समाप्त करना चाहते हैं) में scn.close() पर कॉल करें। acceptAndOpen को IOException फेंकना चाहिए, जिसे आप पकड़ सकते हैं और फिर स्वीकृति-थ्रेड को शानदार ढंग से समाप्त कर सकते हैं।

ServerSocketConnection scn = 
    (ServerSocketConnection) Connector.open("socket://:1234"); 

Thread t = new Thread(){ 
    public void run(){ 
     // Wait for a connection. 
     try { 
      SocketConnection sc = (SocketConnection) scn.acceptAndOpen(); 
      //do other operation 
     } catch (IOException e) { 
      // Log the exception 
     } 
    } 
}; 

t.start(); 

// ... 

// Somewhere else... 
// Cancel the acceptAndOpen. 
scn.close(); 

एक अच्छा विचार एक तुल्यकालन तंत्र लागू करने के लिए ताकि आप सॉकेट सही बंद नहीं करते के बाद acceptAndOpen माध्यम से चला गया होगा।

Answer 6

मुझे लगता है कि तुम सिर्फ कनेक्शन बंद करने की आवश्यकता होगी - तो बस scn धागे के एक क्षेत्र बनाने के लिए और लागू:

public void stop() { 
    scn.close(); 
} 

और अपने मुख्य विधि कोड IOException या अन्य संकेत पर शान से बाहर निकलने के लिए कि आप कर चुके हैं (जैसा कि आपके पास पहले से ही है)।

Answer 7

मैं अभी इस पृष्ठ पर एक ही जवाब की तलाश में आया हूं।मैं एक तरह से धागे को बंद करने के लिए मिला है और इस मैं क्या सर्वर समाप्त करने के लिए करना है:

private Thread serverThread; 

public void setUp(){ 
    //Run the server 
    serverThread = new Thread() { 
     public void run() { 
      try { 
       new Server(); //it calls acceptAndOpen() here 
      } catch (IOException ex) { 
       ex.printStackTrace(); 
      } 
     } 
    }; 
    serverThread.start(); 
} 

public void tearDown() { 
    serverThread = null; 
    System.gc(); 
} 

असल में, अपने सर्वर धागा अशक्त करने के लिए अपने संदर्भ बनाने, और उसके बाद अपने सर्वर है जो कचरा कलेक्टर संसाधनों को साफ करते हैं () तुम्हारे लिए।

नोट हालांकि: यह एकदम सही से दूर है, हम अपना काम करने में जी सी पर निर्भर करते हैं कभी नहीं करना चाहिए, लेकिन यह हर मैं इसे की कोशिश की है