नवीन शेड्यूल्ड थ्रेडपूल पद्धत

टास्क पूलचा आणखी एक प्रकार म्हणजे शेड्यूल्ड टास्क पूल. नावानुसार, आम्ही असे गृहीत धरू शकतो की एखादे विशिष्ट कार्य केव्हा सुरू केले जावे हे शेड्यूल करण्यासाठी आम्ही हा प्रकार वापरतो.

या प्रकारची सेवा उपयोगी पडते जेव्हा आमच्याकडे काही वेळ निघून गेल्यावर क्रियाकलाप सुरू करण्याचे कार्य असते किंवा आम्हाला आवर्ती कार्य शेड्यूल करायचे असते.

एक वापरण्यासाठी, आम्ही Executors.newScheduledThreadPool(1) ला कॉल करतो .

आम्ही पॅरामीटर्सबद्दल थोड्या वेळाने बोलू. परंतु आत्तासाठी, आपल्याला हे माहित असणे आवश्यक आहे की जेव्हा ही पद्धत म्हटली जाते तेव्हा आपल्याला एक शेड्युल्ड एक्झेक्यूटर सर्व्हिस ऑब्जेक्ट मिळतो.

ScheduledExecutorService हा एक इंटरफेस आहे जो ExecutorService चा विस्तार करतो .

या इंटरफेसमध्ये खालील पद्धती दिसतात:

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(int corePoolSize)

newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

दोन्ही पद्धती एक थ्रेड पूल तयार करतील जे निर्दिष्ट विलंबानंतर किंवा वेळोवेळी कार्यान्वित करण्यासाठी क्रिया शेड्यूल करू शकतात.

ScheduledThreadPool कसे कार्य करते हे पाहण्यासाठी एक उदाहरण पाहू .

उदाहरणार्थ, समजा आमच्याकडे दर 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 सेकंदात आपण पाहतो:

सर्वसाधारणपणे, आम्ही उदाहरणाप्रमाणे नियतकालिक "हाउसकीपिंग" कार्ये करण्यासाठी असा पूल वापरू शकतो. हाऊसकीपिंग कार्ये अशी कार्ये आहेत जी मुख्य कार्यक्रम काय करत आहे याची पर्वा न करता पूर्ण करणे आवश्यक आहे.