newScheduledThreadPool विधि

एक अन्य प्रकार का टास्क पूल शेड्यूल्ड टास्क पूल है। नाम से देखते हुए, हम मान सकते हैं कि हम इस प्रकार का उपयोग शेड्यूल करने के लिए करते हैं जब किसी विशेष कार्य को लॉन्च किया जाना चाहिए।

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

एक का उपयोग करने के लिए, हम Executors.newScheduledThreadPool(1) कहते हैं ।

हम थोड़ी देर बाद मापदंडों के बारे में बात करेंगे। लेकिन अभी के लिए, हमें यह जानने की जरूरत है कि जब इस पद्धति को कहा जाता है, तो हमें एक शेड्यूल्ड एक्ज़ीक्यूटर सर्विस ऑब्जेक्ट मिलता है।

शेड्यूल्ड एक्ज़ीक्यूटर सर्विस एक इंटरफ़ेस है जो एक्ज़ीक्यूटर सर्विस का विस्तार करता है ।

इस इंटरफ़ेस में निम्न विधियाँ दिखाई देती हैं:

ScheduledFuture<?>
schedule(Runnable command,
                                  long delay, TimeUnit unit);

<V> ScheduledFuture<V>
schedule(Callable<V> callable,
                                      long delay, TimeUnit unit);

ScheduledFuture<?>
scheduleAtFixedRate(Runnable command,
                                             long initialDelay,
                                             long period,
                                             TimeUnit unit);

ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                long initialDelay,
                                                long delay,
                                                TimeUnit unit);

तो इंटरफ़ेस हमें नियमित अंतराल पर या कुछ देरी के बाद कार्य चलाने देता है।

NewScheduledThreadPool पद्धति पर अधिक।

हम इसे कई तरह से कह सकते हैं:

newScheduledThreadPool(int corePoolSize)

newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

दोनों विधियां एक थ्रेड पूल बनाएंगी जो निर्दिष्ट देरी या समय-समय पर निष्पादित करने के लिए क्रियाएं शेड्यूल कर सकती हैं।

शेड्यूल्ड थ्रेडपूल कैसे काम करता है, यह देखने के लिए आइए एक उदाहरण देखें ।

उदाहरण के लिए, मान लें कि हमारे पास हर 5 सेकंड में ईमेल की जांच करने का कार्य है, लेकिन यह चेक मुख्य कार्यक्रम को प्रभावित नहीं करना चाहिए और अतिरिक्त संसाधनों की संभावित खपत पर जोर देता है।

हमारे पास एक टास्क क्लास है जो चेकिंग ईमेल का अनुकरण करती है।

public class Task implements Runnable {
   @Override
   public void run() {
       System.out.println("Checking email...");
   }
}

अगला, हम एक थ्रेड पूल बनाते हैं और चेक शेड्यूल करते हैं।

ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
executorService.scheduleAtFixedRate(new Task(), 0, 5, TimeUnit.SECONDS);

आउटपुट में, हर 5 सेकंड में हम देखते हैं:

सामान्य तौर पर, हम ऐसे पूल का उपयोग आवधिक "हाउसकीपिंग" कार्यों को करने के लिए कर सकते हैं, जैसा कि उदाहरण में दिया गया है। हाउसकीपिंग कार्य ऐसे कार्य हैं जिन्हें मुख्य कार्यक्रम क्या कर रहा है, इसकी परवाह किए बिना किया जाना चाहिए।