కొత్త షెడ్యూల్డ్ థ్రెడ్‌పూల్ పద్ధతి

మరొక రకమైన టాస్క్ పూల్ షెడ్యూల్డ్ టాస్క్ పూల్. పేరును బట్టి చూస్తే, ఒక నిర్దిష్ట పనిని ఎప్పుడు ప్రారంభించాలో షెడ్యూల్ చేయడానికి మేము ఈ రకాన్ని ఉపయోగిస్తాము.

కొంత సమయం గడిచిన తర్వాత కార్యకలాపాన్ని ప్రారంభించేందుకు లేదా మేము పునరావృతమయ్యే పనిని షెడ్యూల్ చేయాలనుకున్నప్పుడు ఈ రకమైన సేవ ఉపయోగకరంగా ఉంటుంది.

ఒకదాన్ని ఉపయోగించడానికి, మేము Executors.newScheduledThreadPool(1) అని పిలుస్తాము .

మేము కొంచెం తరువాత పారామితుల గురించి మాట్లాడుతాము. కానీ ప్రస్తుతానికి, మనం తెలుసుకోవలసినది ఏమిటంటే, ఈ పద్ధతిని పిలిచినప్పుడు మనకు ScheduledExecutorService వస్తువు లభిస్తుంది.

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 సెకన్లకు మనం చూస్తాము:

సాధారణంగా, ఉదాహరణలో వలె ఆవర్తన "హౌస్ కీపింగ్" పనులను నిర్వహించడానికి మేము అటువంటి పూల్‌ను ఉపయోగించవచ్చు. హౌస్ కీపింగ్ పనులు ప్రధాన కార్యక్రమం ఏమి చేస్తున్నప్పటికీ తప్పనిసరిగా నిర్వహించాల్సిన పనులు.