दिलचस्प पोस्ट
Java.lang को कैसे ठीक करें। असमर्थित क्लास संस्करण त्रुटि: असमर्थित प्रमुख.मोनोर संस्करण एकल ऑब्जेक्ट ऑब्जेक्ट ओरिएंटेड क्यों हैं? कोणीय 2 राउटर कोई आधार href सेट नहीं है ग्रेग में 'के बाद नहीं' के लिए रेगेक्स लुकआहेड पोस्टग्रेएसक्यूएल के साथ इसी तरह की स्ट्रिंग ढूँढना एकाधिक फाइलों के साथ एक मल्टीपार्ट HTTP अनुरोध क्या दिखना चाहिए? Google ग्लास पूर्वावलोकन छवि नए XE10 रिहाई के साथ तले हुए H: बटन और h के बीच का अंतर: कमांड बटन AngularJS – बूलीयन मूल्यों वाले मॉडल के लिए रेडियो बटन बाध्यकारी यूआरएल के आधार पर सक्रिय नेविगेशन क्लास जोड़ें यदि मैं मौजूद नहीं है तो मैं एक निर्देशिका कैसे बना सकता हूं? सेल्यियर से UIImage – iPhone SDK MySQL – कैसे सैम बार? क्या यह WCF सेवाओं के साथ स्वयं ट्रैकिंग इकाइयों का उपयोग करने की सिफारिश की है? कैसे जानती है कि .keyup () एक कैरेक्टर कुंजी है (jQuery)

जावा में कुछ निर्दिष्ट समय सीमा के बाद धागा को मारना

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

Solutions Collecting From Web of "जावा में कुछ निर्दिष्ट समय सीमा के बाद धागा को मारना"

Runnable निष्पादित करने के लिए ExecutorService का उपयोग करें, चेकआउट तरीके जिसमें आप टाइमआउट निर्दिष्ट कर सकते हैं उदाहरण के लिए

 ExecutorService executor = Executors.newSingleThreadExecutor(); executor.invokeAll(Arrays.asList(new Task()), 10, TimeUnit.MINUTES); // Timeout of 10 minutes. executor.shutdown(); 

यहां पाठ्यक्रम का Task Runnable

क्यों नहीं एक विशेष समय के बाद interrupt() इसे interrupt() ? आपका स्पॉन्डेड थ्रेड InterruptedException ठीक से प्रबंधित करने में सक्षम होना होगा।

सूत्रों को साफ रूप से बंद करने के बारे में अधिक जानकारी के लिए इस लेख ( http://www.javaspecialists.eu/archive/Issue056.html ) देखें

निष्पादक / भविष्य के ढांचे को भी देखें, जो परिणामों को इकट्ठा करने और / या विशिष्ट समय सीमाओं के भीतर धागा समाप्त करने के लिए उपयोगी तरीके प्रदान करते हैं।

प्रत्यक्ष नहीं; मुझे लगता है कि उस धागा पर उस समय सीमा में शामिल होने के लिए सबसे आसान तरीका है (), और थ्रेड को बीच में डाल देना यदि वह समाप्त होने के समय तक नहीं किया गया है।

इसलिए,

 Thread t = ... t.join(timelimit); if (t.isAlive) t.interrupt(); 

सूचना मैं वास्तव में इसे हत्या करने के बजाय बीच में इस्तेमाल किया, यह बहुत सुरक्षित है मैं थ्रेडों को सीधे जोड़ तोड़ने के बजाए निष्पादक का उपयोग करने की सलाह देता हूं I

आप एओपी और jcabi- पहलुओं (मैं एक डेवलपर हूँ) से अपनी विधि के लिए एक @Timeable एनोटेशन का उपयोग कर सकते हैं:

 @Timeable(limit = 1, unit = TimeUnit.SECONDS) String load(String resource) { // do something time consuming } 

जब आपकी सीमा तक पहुंचने पर समय सीमा समाप्त हो जाएगी interrupted() ध्वज को true सेट किया जाएगा और यह आपकी स्थिति सही ढंग से संभालने और निष्पादन को रोकने के लिए आपका काम है। सामान्यतः यह Thread.sleep(..) द्वारा किया जाता है।

थ्रेड के लिए एपीआई दस्तावेज़ों से जुड़े कारणों के लिए एक थ्रेड को आम तौर पर एक बुरा विचार है।

यदि आप मर चुके हैं, तो पूरी नई प्रक्रिया का उपयोग करें

अन्यथा सामान्य बात यह है कि धागा चुनाव प्रणाली। System.nanoTime , एक (संभावित volatile ) ध्वज को मतदान, एक "ज़हर की गोली" या उस प्रकृति का कुछ कतार।

ब्रायन का अधिकार, इसे बाधित करने से धागा को "रोकना" की तुलना में सुरक्षित है
क्या होगा यदि धागा मध्य-संशोधन में एक ऑब्जेक्ट लॉक कर रहा है, और अचानक बंद हो जाता है (जिसके कारण लॉक जारी किया जा सकता है)? आपको अजीब परिणाम मिलता है

destroy() न करें destroy() उपयोग न करें क्योंकि इससे कोई सफाई नहीं होती है

सबसे आसान तरीके से join() उपयोग करना है, जैसे

 try { thread.join(); } catch (InterruptedException e) {//log exception...} 

आप एक ExecutorService उपयोग कर सकते हैं यह कई अर्थ पैदा करेगा यदि आपके पास कई थ्रेड्स हैं जो एक साथ चल रहे हैं यदि आपको अन्य धागे चलने के दौरान नया थ्रेड्स बनाने की ज़रूरत होती है, तो आप इसे BlockingQueue साथ जोड़ सकते हैं।

ThreadPoolExecutor (एक ExecutorService कार्यान्वयन) तर्क के रूप में एक BlockingQueue ले सकता है, और आप बस कतार में नए सूत्र जोड़ सकते हैं। जब आप कर लेंगे तो आप बस ThreadPoolExecutor समाप्त कर देंगे

 private BlockingQueue<Runnable> queue; ... ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 10, new Long(1000), TimeUnit.MILLISECONDS, this.queue); 

आप कतार में जोड़े गए सभी थ्रेडों की गिनती रख सकते हैं। जब आपको लगता है कि आप कर रहे हैं (कतार खाली है, शायद?) बस इस की तुलना इसकी तुलना करें

  if (issuedThreads == pool.getCompletedTaskCount()) { pool.shutdown(); } 

अगर दो मैच, आप कर रहे हैं पूल को समाप्त करने का दूसरा तरीका एक लूप में दूसरा इंतजार करना है:

 try { while (!this.pool.awaitTermination(1000, TimeUnit.MILLISECONDS)); } catch (InterruptedException e) {//log exception...} 

कुछ उपयोगी परिवर्तन, जेईपी 266 के भाग के रूप में प्रस्तुत किए गए थे। जावा 9 के बाद से पूर्णतया फ़्यूचर में। यानी टाइमआउट विधि का उपयोग करना, अब यह लिखना संभव है:

 CompletableFuture.runAsync(thread::run) .orTimeout(30, TimeUnit.SECONDS) .exceptionally(throwable -> { log.error("An error occurred", throwable); return null; }); 

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

 import com.google.common.util.concurrent.ThreadFactoryBuilder; import java.time.Duration; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executors; import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.util.concurrent.TimeoutException; import static lombok.AccessLevel.PRIVATE; import lombok.AllArgsConstructor; import lombok.experimental.Delegate; @AllArgsConstructor(access = PRIVATE) public class TimeoutableCompletableFuture<T> extends CompletableFuture<T> { public static TimeoutableCompletableFuture<Void> runAsync( Runnable runnable) { return new TimeoutableCompletableFuture<>( CompletableFuture.runAsync(runnable)); } @Delegate private final CompletableFuture<T> baseFuture; public TimeoutableCompletableFuture<T> orTimeout(Duration duration) { final CompletableFuture<T> otherFuture = new CompletableFuture<>(); Executors.newScheduledThreadPool( 1, new ThreadFactoryBuilder() .setDaemon(true) .setNameFormat("timeoutable-%d") .build()) .schedule(() -> { TimeoutException ex = new TimeoutException( "Timeout after " + duration); return otherFuture.completeExceptionally(ex); }, duration.toMillis(), MILLISECONDS); return new TimeoutableCompletableFuture<>( baseFuture.applyToEither(otherFuture, a -> a)); } } 

बेशक, ऊपर कोड आसानी से सिर्फ एक स्थिर कारखाने विधि के रूप में फिर से लिखा जा सकता है:

 public static CompletableFuture<Void> runAsyncOrTimeout( Runnable runnable, long timeout, TimeUnit unit) { CompletableFuture<Void> other = new CompletableFuture<>(); Executors.newScheduledThreadPool( 1, new ThreadFactoryBuilder() .setDaemon(true) .setNameFormat("timeoutafter-%d") .build()) .schedule(() -> { TimeoutException ex = new TimeoutException( "Timeout after " + timeout); return other.completeExceptionally(ex); }, timeout, unit); return CompletableFuture.runAsync(runnable).applyToEither(other, a -> a); }