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

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

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

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

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

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

Java university
तरीका व्याख्या 

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);
एक पुनरावर्ती क्रिया बनाता है और निष्पादित करता है जो पहले निर्दिष्ट प्रारंभिक विलंब के बाद और फिर निर्दिष्ट अवधि के बाद चलता है। दूसरे शब्दों में, निष्पादन आरंभिक विलंब के बाद शुरू होगा , फिर आरंभिक विलंब + अवधि , फिर आरंभिक विलंब + 2 * अवधि , और इसी तरह। 

ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                long initialDelay,
                                                long delay,
                                                TimeUnit unit);
एक आवर्ती कार्रवाई बनाता है और निष्पादित करता है जो पहले निर्दिष्ट प्रारंभिक देरी के बाद निष्पादित होता है, और फिर एक निष्पादन के पूरा होने और अगले की शुरुआत के बीच निर्दिष्ट देरी के साथ।

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

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

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


newScheduledThreadPool(int corePoolSize)
corePoolSize पूल में रखने के लिए थ्रेड्स की संख्या है, भले ही वे निष्क्रिय हों। 

newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

corePoolSize पूल में रखने के लिए थ्रेड्स की संख्या है, भले ही वे निष्क्रिय हों।

थ्रेडफैक्टरी वह फैक्ट्री है जिसका उपयोग नए थ्रेड्स बनाते समय किया जाता है।

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

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

उदाहरण के लिए, मान लें कि हमारे पास हर 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 सेकंड में हम देखते हैं:

ईमेल जांचा जा रहा है...

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