ThreadPoolExecutor

"సాధారణ ప్రోగ్రామర్లు ఎప్పటికప్పుడు చేయవలసిన అనేక చిన్న పనులను కలిగి ఉన్నారనే వాస్తవంతో త్వరగా లేదా తరువాత పట్టుకు వస్తారు."

"మీరు ఒక గేమ్ వ్రాస్తున్నట్లయితే, అది వ్యక్తిగత పాత్రలు చేసే చర్యలు."

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

"త్వరగా లేదా తరువాత, అన్ని పెద్ద పనులు చిన్న, నిర్వహించదగిన పనుల సమితిగా విభజించబడ్డాయి."

"కాబట్టి, ఈ సందర్భంలో, ఒక సూక్ష్మమైన ప్రశ్న తలెత్తుతుంది: మీరు వాటన్నింటినీ ఎలా నిర్వహించాలి? మీరు ఒక నిమిషంలో అనేక వందల పనులను చేయవలసి వస్తే? ప్రతి థ్రెడ్ కోసం చాలా వనరులను కేటాయిస్తుంది."

"మరో మాటలో చెప్పాలంటే, థ్రెడ్‌ను సృష్టించడం మరియు నాశనం చేయడం అనేది పని కంటే ఎక్కువ సమయం మరియు వనరులను పట్టవచ్చు."

"జావా సృష్టికర్తలు ఈ సమస్యకు ఒక సొగసైన పరిష్కారంతో ముందుకు వచ్చారు: ThreadPoolExecutor .

" థ్రెడ్‌పూల్ ఎగ్జిక్యూటర్ అనేది లోపల రెండు విషయాలతో కూడిన తరగతి:"

ఎ)  టాస్క్ క్యూ, ఇది ప్రోగ్రామ్‌లో ఉత్పన్నమైనప్పుడు మీరు టాస్క్‌ని జోడించవచ్చు.

బి) థ్రెడ్ పూల్, ఇది ఈ పనులను చేసే థ్రెడ్‌ల సమూహం.

"ఇంకా, ఒక పని పూర్తయిన తర్వాత థ్రెడ్‌లు నాశనం చేయబడవు. బదులుగా, కొత్త పని కనిపించిన వెంటనే ప్రారంభించడానికి సిద్ధంగా ఉండటానికి వారు నిద్రపోతారు."

"మీరు థ్రెడ్‌పూల్ ఎగ్జిక్యూటర్‌ని సృష్టించినప్పుడు , మీరు సృష్టించాల్సిన థ్రెడ్‌ల గరిష్ట సంఖ్యను మరియు క్యూలో ఉంచగల గరిష్ట టాస్క్‌ల సంఖ్యను సెట్ చేయవచ్చు. మరో మాటలో చెప్పాలంటే, మీరు థ్రెడ్‌ల సంఖ్యను 10కి పరిమితం చేయవచ్చు, ఉదాహరణకు, మరియు వాటి సంఖ్య టాస్క్‌లను 100కి క్యూలో ఉంచారు."

" థ్రెడ్‌పూల్ ఎగ్జిక్యూటర్ ఈ విధంగా పనిచేస్తుంది:"

1)  మీరు కొత్త పనిని జోడించినప్పుడు, అది క్యూ చివరిలో ఉంచబడుతుంది.

2)  క్యూ నిండినట్లయితే, మినహాయింపు విసిరివేయబడుతుంది.

3)  ఒక పనిని పూర్తి చేసిన తర్వాత, ప్రతి థ్రెడ్ తదుపరి పనిని క్యూలో నుండి తీసుకొని దానిని అమలు చేయడం ప్రారంభిస్తుంది.

4) క్యూలో టాస్క్‌లు లేకుంటే, కొత్త టాస్క్‌లు జోడించబడే వరకు థ్రెడ్ నిద్రపోతుంది.

"మేము వర్కర్ థ్రెడ్‌ల సంఖ్యను పరిమితం చేసే విధానం ప్రయోజనకరంగా ఉంటుంది, మన వద్ద ఎక్కువ థ్రెడ్‌లు ఉంటే, అవి ఒకదానికొకటి అంతరాయం కలిగిస్తాయి. 5-10 వర్కర్ థ్రెడ్‌లు మరియు టాస్క్‌ల పొడవైన క్యూను కలిగి ఉండటం చాలా ప్రభావవంతంగా ఉంటుంది. టాస్క్‌ల పెరుగుదల కోసం 100 థ్రెడ్‌లను సృష్టించడానికి, ఇది వనరుల కోసం ఒకదానితో ఒకటి పోటీపడుతుంది: మెమరీ, ప్రాసెసర్ సమయం, డేటాబేస్ యాక్సెస్ మొదలైనవి."

" చర్యలో ఉన్న ThreadPoolExecutor యొక్క ఉదాహరణ ఇక్కడ ఉంది :"

ExecutorService service = Executors.newFixedThreadPool(2);

for(int i = 0; i < 10; i++)
{
 service.submit(new Runnable() {
    public void run()
    {
     // Here we download something big from the Internet.
    }
 });
}

"అయ్యో, నాకు కనిపించడం లేదు..."

" కొత్త ఫిక్స్‌డ్‌థ్రెడ్‌పూల్ పద్ధతిని పిలిచినప్పుడు థ్రెడ్‌పూల్ ఎగ్జిక్యూటర్ ఆబ్జెక్ట్ సృష్టించబడుతుంది."

కాబట్టి, దీన్ని ఉపయోగించడం చాలా సులభం. మీరు సబ్మిట్ మెథడ్‌తో దానికి టాస్క్‌ని జోడించిన వెంటనే, ఇది:

ఎ)  టాస్క్‌ని అమలు చేయడానికి స్లీపింగ్ థ్రెడ్ ఒకటి ఉంటే మేల్కొంటుంది.

బి)  వెయిటింగ్ థ్రెడ్ లేకపోతే, అది టాస్క్ కోసం కొత్తదాన్ని సృష్టిస్తుంది.

సి)  థ్రెడ్‌ల గరిష్ట సంఖ్యను చేరుకున్నట్లయితే, అది క్యూ చివరిలో పనిని ఉంచుతుంది.

"నేను ఉద్దేశపూర్వకంగానే ఉదాహరణలో «ఇంటర్నెట్ నుండి పెద్దదిగా డౌన్‌లోడ్ చేస్తున్నాము» అని చేర్చాను. మనకు 100 టాస్క్‌లు ఉంటే «ఇంటర్నెట్ నుండి పెద్దదాన్ని డౌన్‌లోడ్ చేయండి», అప్పుడు వాటిలో చాలా వాటిని ఒకే సమయంలో అమలు చేయడంలో అర్థం లేదు—మేము' మా ఇంటర్నెట్ కనెక్షన్ యొక్క బ్యాండ్‌విడ్త్ పరిమితి ద్వారా నిలిపివేయబడుతుంది. ఈ సందర్భంలో, రెండు థ్రెడ్‌లు సరిపోతాయి. పై ఉదాహరణలో మీరు చూసేది ఇదే:"

ExecutorService service = Executors.newFixedThreadPool(2);

"కొన్ని పనులతో పనిచేయడం అంత కష్టం కాదని తేలింది."

"అవును. మీరు ఊహించిన దానికంటే చాలా సులభం. కానీ కిమ్ మీకు దాని గురించి చెబుతారు."