ఎగ్జిక్యూటర్, ఎగ్జిక్యూటర్ సర్వీస్, కాల్ చేయదగినది

"హాయ్, అమిగో!"

"మొదట సృష్టించబడినప్పుడు ఏదీ పరిపూర్ణంగా ఉండదు. థ్రెడ్‌ల విషయంలో కూడా ఇది వర్తిస్తుంది. కాలక్రమేణా, జావా సృష్టికర్తలు రన్ చేయదగిన ఇంటర్‌ఫేస్ యొక్క లోపాలను ఒప్పించారు. ఇది మినహాయింపులను విసిరేందుకు మద్దతు ఇవ్వలేదు మరియు దానిని కనుగొనడం సాధ్యం చేయలేదు. విధులను నిర్వర్తించడం ఫలితంగా…”

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

"అందుకే కాల్ చేయదగిన ఇంటర్‌ఫేస్ కనుగొనబడింది. ఇది రన్ చేయదగిన మరియు థ్రెడ్ కంటే చిన్న టాస్క్‌లను సమాంతరంగా అమలు చేయడానికి బాగా సరిపోతుంది, ఎందుకంటే ఇది సాధారణ ఇంటర్‌ఫేస్."

"ఇంటర్‌ఫేస్ యొక్క సాధారణ అమలు ఇక్కడ ఉంది:"

class ReverseString implements Callable<String>
{
 String str;

 ReverseString(String str)
 {
  this.str = str;
 }

 public String call() throws Exception
 {
  StringBuilder builder = new StringBuilder(str);
  builder.reverse();
  return builder.toString();
 }
}

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

"అలాగా."

"మరియు ఇప్పుడు కాల్ చేయదగినది ThreadPoolExecutorతో కలిసి ఎలా పని చేస్తుందో చూడండి :

"మొదట, ThreadPoolExecutor క్లాస్ యొక్క సబ్మిట్ మెథడ్ ఒక పారామీటర్ చేయబడిన ఫ్యూచర్ ఆబ్జెక్ట్‌ని అందిస్తుంది. మీరు ఈ ఆబ్జెక్ట్‌ని ఉపయోగించి ఒక పనిని పూర్తి చేసి ఉంటే దాన్ని కనుగొనవచ్చు మరియు ఫలితాన్ని పొందవచ్చు."

"ఇది ఎలా పని చేస్తుందో ఇక్కడ ఉంది:"

// 1. Create a ThreadPoolExecutor
ExecutorService service = Executors.newFixedThreadPool(5);

// 2. Add a task to it
Future<String> task = service.submit(new ReverseString("Amigo"));

// 3. Wait until the task is done
while(!task.isDone())
{
 Thread.sleep(1);
}

// 4. Try to get the result
//We will get either the result, or an exception if one occurred while the task was being executed
try
{
 System.out.println("Full string : " + task.get());
}
catch (Exception ie)
{
 ie.printStackTrace(System.err);
}
  
// 5. Stop the ThreadPool.
service.shutdown();

"చాలా దూరం! నాకు ముఖ్యంగా ఫ్యూచర్ క్లాస్ అంటే చాలా ఇష్టం. దానికి ఎలాంటి పద్ధతులు ఉన్నాయి?"

"ఇవి అత్యంత ఆసక్తికరమైనవి:"

boolean cancel(boolean mayInterrupt);

boolean isCancelled();

boolean isDone();

V get() throws InterruptedException, ExecutionException;

"కూల్! కాబట్టి మీరు పనులను కూడా ఆపవచ్చు."

"దీనిపై ఎక్కువగా ఆధారపడవద్దు-ప్రతి థ్రెడ్ ఆగదు. కానీ ఒక పని ఇప్పటికీ క్యూలో ఉంటే, ఇది బాగా పని చేస్తుంది."

"నేను ఈ విధానాన్ని ఇష్టపడుతున్నాను. థ్రెడ్‌లను మీరే సృష్టించడం మరియు వాటి నుండి ఫలితాన్ని బయటకు తీయడానికి ప్రయత్నించడం కంటే ఇది చాలా సౌకర్యవంతంగా ఉంటుంది."

"అద్భుతం. ఈరోజు ఇక్కడే ముగిస్తాం."