బహుళ-థ్రెడ్ అప్లికేషన్‌ను అభివృద్ధి చేస్తున్నప్పుడు, మేము సాధారణంగా థ్రెడ్‌ల పనిని నిర్వహించాలి. మా అప్లికేషన్ ఎంత పెద్దదైతే మరియు మల్టీథ్రెడ్ టాస్క్‌ల కోసం మనకు ఎక్కువ థ్రెడ్‌లు అవసరమవుతాయిరన్ చేయదగినదిమనం సృష్టించే వస్తువులు.

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

థ్రెడ్ పూల్ మరియు ThreadPoolExecutor ఇక్కడ మా సహాయానికి వస్తాయి.

థ్రెడ్ పూల్ అనేది ముందుగా ప్రారంభించబడిన థ్రెడ్‌ల సమితి. దీని పరిమాణం స్థిరంగా లేదా మారవచ్చు.

థ్రెడ్‌ల కంటే ఎక్కువ టాస్క్‌లు ఉంటే, టాస్క్‌లు టాస్క్ క్యూలో వేచి ఉంటాయి. పూల్‌లోని Nth థ్రెడ్ క్యూ నుండి ఒక పనిని తీసుకుంటుంది మరియు అది పూర్తయిన తర్వాత, థ్రెడ్ క్యూ నుండి కొత్త టాస్క్‌ను ఎంచుకుంటుంది. క్యూలో ఉన్న అన్ని టాస్క్‌లు అమలు చేయబడిన తర్వాత, థ్రెడ్‌లు సక్రియంగా ఉంటాయి మరియు కొత్త పనుల కోసం వేచి ఉంటాయి. కొత్త టాస్క్‌లు కనిపించినప్పుడు, థ్రెడ్‌లు వాటిని కూడా అమలు చేయడం ప్రారంభిస్తాయి.

ThreadPoolExecutor

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

Java university

ప్రధాన ఇంటర్‌ఫేస్‌లు ఎగ్జిక్యూటర్ మరియు ఎగ్జిక్యూటర్ సర్వీస్ .

ఎగ్జిక్యూటర్ అనేది ఒకే శూన్యమైన ఎగ్జిక్యూట్ (రన్ చేయదగిన రన్ చేయదగిన) పద్ధతితో కూడిన ఇంటర్‌ఫేస్.

ఈ పద్ధతిని అమలు చేయడానికి ఒక పనిని పంపినప్పుడు, అది భవిష్యత్తులో అసమకాలికంగా అమలు చేయబడుతుందని తెలుసుకోండి.

ExecutorService — కార్యనిర్వాహక ఇంటర్‌ఫేస్‌ను విస్తరించే ఇంటర్‌ఫేస్, టాస్క్‌లను అమలు చేయడానికి సామర్థ్యాలను జోడిస్తుంది. ఇది రన్నింగ్ టాస్క్‌కు అంతరాయం కలిగించడానికి మరియు థ్రెడ్ పూల్‌ను ముగించే పద్ధతులను కూడా కలిగి ఉంది.

ThreadPoolExecutor ఎగ్జిక్యూటర్ మరియు ఎగ్జిక్యూటర్ సర్వీస్ ఇంటర్‌ఫేస్‌లను అమలు చేస్తుందిమరియు టాస్క్ క్రియేషన్‌ను టాస్క్ ఎగ్జిక్యూషన్ నుండి వేరు చేస్తుంది. మేము అమలు చేయగల వస్తువులను అమలు చేయాలిమరియు వాటిని కార్యనిర్వాహకుడికి పంపాలి. ThreadPoolExecutorఅప్పుడు టాస్క్‌లను అమలు చేయడం మరియు థ్రెడ్‌లను సృష్టించడం మరియు పని చేయడం బాధ్యత వహిస్తుంది .

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

ThreadPoolExecutor 4 కన్స్ట్రక్టర్లను కలిగి ఉంది:


ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime, 
TimeUnit unit, 
BlockingQueue<Runnable> workQueue)
    

ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
    

ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime, 
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory)
    

ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime, 
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory, 
RejectedExecutionHandler handler)

ThreadPoolExecutor కన్స్ట్రక్టర్ కింది పారామితులను కలిగి ఉంది :

corePoolSize ఎగ్జిక్యూటర్ సేవ ప్రారంభమైనప్పుడు ఎన్ని థ్రెడ్‌లు సిద్ధంగా ఉంటాయో (ప్రారంభించబడతాయో) ఈ పరామితి సూచిస్తుంది.
గరిష్ట పూల్ పరిమాణం కార్యనిర్వాహక సేవ సృష్టించగల గరిష్ట సంఖ్యలో థ్రెడ్‌లు.
అలైవ్ టైమ్ థ్రెడ్‌ల సంఖ్య కంటే ఎక్కువగా ఉన్నట్లయితే, విముక్తి పొందిన థ్రెడ్ నాశనం కావడానికి ముందు జీవించే సమయంcorePoolSize. సమయ యూనిట్లు తదుపరి పరామితిలో పేర్కొనబడ్డాయి.
యూనిట్ సమయ యూనిట్లు (గంటలు, నిమిషాలు, సెకన్లు, మిల్లీసెకన్లు మొదలైనవి).
పని క్యూ పనుల కోసం క్యూ అమలు.
హ్యాండ్లర్ పూర్తి చేయలేని పనులను నిర్వహించేవాడు.
థ్రెడ్ ఫ్యాక్టరీ డిమాండ్‌పై కొత్త థ్రెడ్‌లను సృష్టించే వస్తువు. థ్రెడ్ ఫ్యాక్టరీలను ఉపయోగించడం వలన కొత్త థ్రెడ్ హార్డ్‌వేర్‌కు కాల్‌లు స్వతంత్రంగా ఉంటాయి, ప్రత్యేక థ్రెడ్ సబ్‌క్లాస్‌లు, ప్రాధాన్యతలు మొదలైనవాటిని ఉపయోగించడానికి అప్లికేషన్‌లను అనుమతిస్తుంది.

ThreadPoolExecutorని సృష్టిస్తోంది

ఎగ్జిక్యూటర్స్ యుటిలిటీ క్లాస్ ThreadPoolExecutor యొక్క సృష్టిని సులభతరం చేస్తుంది . ఈ యుటిలిటీ క్లాస్ యొక్క పద్ధతులు a సిద్ధం చేయడంలో మాకు సహాయపడతాయిThreadPoolExecutorవస్తువు.

newFixedThreadPool — ఒక థ్రెడ్ పూల్‌ను సృష్టిస్తుంది, అది ఎన్ని టాస్క్‌లనైనా అమలు చేయడానికి నిర్ణీత సంఖ్యలో థ్రెడ్‌లను తిరిగి ఉపయోగిస్తుంది. 

ExecutorService executor = Executors.newFixedThreadPool(10);
newWorkStealingPool — థ్రెడ్‌ల సంఖ్య JVMకి అందుబాటులో ఉన్న ప్రాసెసర్ కోర్ల సంఖ్యకు సమానంగా ఉండే థ్రెడ్ పూల్‌ను సృష్టిస్తుంది. డిఫాల్ట్ కాన్కరెన్సీ స్థాయి ఒకటి. అంటే JVMకి అందుబాటులో ఉన్న CPU కోర్లన్నింటిని పూల్‌లో సృష్టించబడతాయి. కాన్కరెన్సీ స్థాయి 4 అయితే, కోర్ల సంఖ్యకు బదులుగా పాస్ చేసిన విలువ ఉపయోగించబడుతుంది. 

ExecutorService executor = Executors.newWorkStealingPool(4);
newSingleThreadExecutor — అన్ని టాస్క్‌లను అమలు చేయడానికి ఒకే థ్రెడ్‌తో పూల్‌ను సృష్టిస్తుంది. 

ExecutorService executor = Executors.newSingleThreadExecutor();
newCachedThreadPool — అవసరమైన విధంగా కొత్త థ్రెడ్‌లను సృష్టించే థ్రెడ్ పూల్‌ను సృష్టిస్తుంది, అయితే గతంలో సృష్టించిన థ్రెడ్‌లు అందుబాటులో ఉన్నప్పుడు వాటిని మళ్లీ ఉపయోగిస్తుంది. 

ExecutorService executor = Executors.newCachedThreadPool();
newScheduledThreadPool — ఇచ్చిన ఆలస్యం తర్వాత లేదా క్రమానుగతంగా అమలు చేయడానికి ఆదేశాలను షెడ్యూల్ చేయగల థ్రెడ్ పూల్‌ను సృష్టిస్తుంది. 

ScheduledExecutorService executor = Executors.newScheduledThreadPool(10);

మేము క్రింది పాఠాలలో ప్రతి రకమైన పూల్‌ను పరిశీలిస్తాము.