ఎగ్జిక్యూటర్ సర్వీస్ ఇంటర్ఫేస్

మీకు ఎగ్జిక్యూటర్ ఇంటర్‌ఫేస్ ఎందుకు అవసరం?

జావా 5కి ముందు, మీరు మీ అప్లికేషన్‌లో మీ స్వంత కోడ్ థ్రెడ్ మేనేజ్‌మెంట్ మొత్తాన్ని వ్రాయవలసి ఉంటుంది. అదనంగా, సృష్టించడం aకొత్త థ్రెడ్ఆబ్జెక్ట్ అనేది రిసోర్స్-ఇంటెన్సివ్ ఆపరేషన్, మరియు ప్రతి తేలికైన పని కోసం కొత్త థ్రెడ్‌ని సృష్టించడం సమంజసం కాదు. మరియు ఈ సమస్య మల్టీ-థ్రెడ్ అప్లికేషన్‌ల యొక్క ప్రతి డెవలపర్‌కు ఖచ్చితంగా తెలిసినందున, వారు ఈ కార్యాచరణను జావాలోకి ఎగ్జిక్యూటర్ ఫ్రేమ్‌వర్క్‌గా తీసుకురావాలని నిర్ణయించుకున్నారు .

పెద్ద ఆలోచన ఏమిటి? ఇది చాలా సులభం: ప్రతి కొత్త పనికి కొత్త థ్రెడ్‌ని సృష్టించే బదులు, థ్రెడ్‌లు ఒక రకమైన "స్టోరేజ్"లో ఉంచబడతాయి మరియు కొత్త టాస్క్ వచ్చినప్పుడు, మేము కొత్తదాన్ని సృష్టించే బదులు ఇప్పటికే ఉన్న థ్రెడ్‌ను తిరిగి పొందుతాము.

ఈ ఫ్రేమ్‌వర్క్ యొక్క ప్రధాన ఇంటర్‌ఫేస్‌లు ఎగ్జిక్యూటర్ , ఎగ్జిక్యూటర్ సర్వీస్ మరియు షెడ్యూల్డ్ ఎగ్జిక్యూటర్ సర్వీస్ , వీటిలో ప్రతి ఒక్కటి మునుపటి కార్యాచరణను విస్తరించింది.

ఎగ్జిక్యూటర్ ఇంటర్‌ఫేస్ అనేది బేస్ ఇంటర్‌ఫేస్. ఇది అమలు చేయగల ఆబ్జెక్ట్ ద్వారా అమలు చేయబడిన ఒకే శూన్యమైన అమలు (రన్ చేయదగిన కమాండ్) పద్ధతిని ప్రకటించింది .

ExecutorService ఇంటర్‌ఫేస్ మరింత ఆసక్తికరంగా ఉంటుంది . ఇది పనిని పూర్తి చేయడానికి, అలాగే ఒక రకమైన ఫలితాన్ని తిరిగి ఇచ్చే పద్ధతులను నిర్వహించడానికి పద్ధతులను కలిగి ఉంది. దాని పద్ధతులను మరింత వివరంగా పరిశీలిద్దాం:

ExecutorService తో పని చేయడానికి ఒక చిన్న ఉదాహరణను చూద్దాం .

import java.util.List;
import java.util.concurrent.*;

public class ExecutorServiceTest {
   public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
//Create an ExecutorService for 2 threads
       java.util.concurrent.ExecutorService executorService = new ThreadPoolExecutor(2, 2, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
// Create 5 tasks
       MyRunnable task1 = new MyRunnable();
       MyRunnable task2 = new MyRunnable();
       MyRunnable task3 = new MyRunnable();
       MyRunnable task4 = new MyRunnable();
       MyRunnable task5 = new MyRunnable();

       final List<MyRunnable> tasks = List.of(task1, task2, task3, task4, task5);
// Pass a list that contains the 5 tasks we created
       final List<Future<Void>> futures = executorService.invokeAll(tasks, 6, TimeUnit.SECONDS);
       System.out.println("Futures received");

// Stop the ExecutorService
       executorService.shutdown();

       try {
           TimeUnit.SECONDS.sleep(3);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println(executorService.isShutdown());
       System.out.println(executorService.isTerminated());
   }

   public static class MyRunnable implements Callable<Void> {

       @Override
       public void call() {
// Add 2 delays. When the ExecutorService is stopped, we will see which delay is in progress when the attempt is made to stop execution of the task
           try {
               TimeUnit.SECONDS.sleep(3);
           } catch (InterruptedException e) {
               System.out.println("sleep 1: " + e.getMessage());
           }
           try {
               TimeUnit.SECONDS.sleep(2);
           } catch (InterruptedException e) {
               System.out.println("sleep 2: " + e.getMessage());
           }
           System.out.println("done");
           return null;
       }
   }
}

అవుట్‌పుట్:

ప్రతి పని 5 సెకన్ల పాటు నడుస్తుంది. మేము రెండు థ్రెడ్‌ల కోసం పూల్‌ను సృష్టించాము, కాబట్టి అవుట్‌పుట్ యొక్క మొదటి రెండు లైన్లు ఖచ్చితమైన అర్ధాన్ని కలిగి ఉంటాయి.

ప్రోగ్రామ్ ప్రారంభమైన ఆరు సెకన్ల తర్వాత, ఇన్వోక్ ఆల్ మెథడ్ సమయం ముగిసింది మరియు ఫలితం ఫ్యూచర్‌ల జాబితాగా అందించబడుతుంది . ఫ్యూచర్స్ అందుకున్న అవుట్‌పుట్ స్ట్రింగ్ నుండి ఇది చూడవచ్చు .

మొదటి రెండు పనులు పూర్తయిన తర్వాత మరో రెండు పనులు ప్రారంభమవుతాయి. కానీ invokeAll పద్ధతిలో సెట్ చేసిన గడువు ముగిసినందున, ఈ రెండు టాస్క్‌లను పూర్తి చేయడానికి సమయం లేదు. వారు "రద్దు" ఆదేశాన్ని అందుకుంటారు. అందుకే అవుట్‌పుట్‌లో స్లీప్ 1తో రెండు లైన్లు ఉన్నాయి: నిద్రకు అంతరాయం .

ఆపై మీరు పూర్తి చేసిన మరో రెండు పంక్తులను చూడవచ్చు . InvokeAll పద్ధతిని వివరించేటప్పుడు నేను పేర్కొన్న సైడ్ ఎఫెక్ట్ ఇది .

ఐదవ మరియు చివరి టాస్క్ ఎప్పటికీ ప్రారంభించబడదు, కాబట్టి అవుట్‌పుట్‌లో దాని గురించి మనకు ఏమీ కనిపించదు.

చివరి రెండు పంక్తులు isShutdown మరియు isTerminated పద్ధతులకు కాల్ చేయడం వలన ఏర్పడినవి .

ఈ ఉదాహరణను డీబగ్ మోడ్‌లో అమలు చేయడం మరియు గడువు ముగిసిన తర్వాత విధి స్థితిని చూడటం కూడా ఆసక్తికరంగా ఉంటుంది ( executorService.shutdown(); ) తో లైన్‌లో బ్రేక్‌పాయింట్‌ను సెట్ చేయండి ):

మేము రెండు పనులు సాధారణంగా పూర్తయినట్లు మరియు మూడు టాస్క్‌లు "రద్దు" అయినట్లు చూస్తాము .

షెడ్యూల్డ్ ఎగ్జిక్యూటర్ సర్వీస్

కార్యనిర్వాహకుల గురించి మా చర్చను ముగించడానికి, ScheduledExecutorService ని పరిశీలిద్దాం .

దీనికి 4 పద్ధతులు ఉన్నాయి: