C # లో మెమరీ కేటాయింపు చాలా ఖరీదైనది మరియు ఏదైనా పనితీరు-క్లిష్టమైన అనువర్తనానికి కీలకమైన ఆప్టిమైజేషన్ పాయింట్. ఆబ్జెక్ట్ పూలింగ్ అనేది మెమరీ-ఇంటెన్సివ్ అప్లికేషన్ యొక్క ఓవర్ హెడ్ తగ్గించడానికి సహాయపడే ఒక టెక్నిక్.

ఆబ్జెక్ట్ పూలింగ్ పనితీరును ఎలా మెరుగుపరుస్తుంది?

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

ఆబ్జెక్ట్ పూలింగ్ అనేది మెమరీని తగ్గించడానికి ఉపయోగించే ఒక టెక్నిక్ కేటాయింపులు. మెమరీని కేటాయించడం తరచుగా అవసరం లేదు, కానీ మీరు చేసినన్ని సార్లు కేటాయించడం అవసరం లేదు. కొన్ని కారణాల వల్ల ఆబ్జెక్ట్ కేటాయింపులు నెమ్మదిగా ఉంటాయి: అంతర్లీన మెమరీ కుప్పలో కేటాయించబడుతుంది (ఇది విలువ-రకం స్టాక్ కేటాయింపుల కంటే చాలా నెమ్మదిగా ఉంటుంది), మరియు సంక్లిష్ట వస్తువులు చాలా పనితీరు అవసరమయ్యే కన్స్ట్రక్టర్లను కలిగి ఉంటాయి. అలాగే, ఇది కుప్ప ఆధారిత జ్ఞాపకశక్తి కాబట్టి, చెత్త సేకరించేవారు దానిని శుభ్రం చేయాల్సి ఉంటుంది, మీరు దీన్ని చాలా తరచుగా ఆన్ చేస్తే పనితీరును దిగజార్చుతుంది.

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

ఈ కోడ్ 10,000 సార్లు నడుస్తుంది మరియు ఫంక్షన్ ముగింపులో 10,000 అన్‌నోడ్ జాబితాలను మెమరీలో కేటాయించింది.

చెత్త సేకరించేవారు చివరికి నడుస్తున్నప్పుడు, ఈ వ్యర్థాలన్నింటినీ శుభ్రం చేయడం చాలా కష్టమవుతుంది, ఇది జిసి పూర్తయ్యే వరకు వేచి ఉన్న పనితీరుపై ప్రతికూల ప్రభావాన్ని చూపుతుంది.

బదులుగా, మరింత సున్నితమైన విధానం ఏమిటంటే, దాన్ని ఒకసారి ప్రారంభించి, వస్తువును తిరిగి ఉపయోగించడం. మరచిపోకుండా మరియు చెత్త సేకరించేవారిని జాగ్రత్తగా చూసుకోకుండా, మీరు అదే మెమరీ స్థలాన్ని తిరిగి ఉపయోగిస్తున్నారని ఇది నిర్ధారిస్తుంది. ఇది మేజిక్ కాదు మరియు ముందుగానే లేదా తరువాత మీరు శుభ్రం చేయాలి.

ఈ ఉదాహరణ కోసం, పునర్వినియోగపరచదగిన విధానం నడుస్తుంది new List మొదటి కేటాయింపును నిర్వహించడానికి లూప్ ముందు మరియు తరువాత అమలు చేయండి .Clear లేదా మెమరీ స్థలాన్ని ఆదా చేయడానికి డేటాను రీసెట్ చేయండి మరియు వ్యర్థాన్ని సృష్టించింది. ఈ చక్రం చివరలో, మెమరీలో ఒక జాబితా మాత్రమే మిగిలి ఉంటుంది, ఇది వాటిలో 10,000 కన్నా చాలా చిన్నది.

మొదటి కేటాయింపు చేయడానికి లూప్ ముందు కొత్త జాబితాను అమలు చేయండి, ఆపై అమలు చేయండి. మెమరీ స్థలాన్ని ఆదా చేయడానికి డేటాను క్లియర్ చేయండి లేదా పునరుద్ధరించండి మరియు వ్యర్థాలను సృష్టించండి.

ఆబ్జెక్ట్ పూల్ ప్రాథమికంగా ఈ భావన యొక్క సాధారణ అమలు. ఇది తిరిగి ఉపయోగించగల వస్తువుల సమాహారం. ఒకదానికి అధికారిక ఇంటర్ఫేస్ లేదు, కానీ సాధారణంగా వారు అంతర్గత డేటా స్టోర్ కలిగి ఉంటారు మరియు రెండు పద్ధతులను అమలు చేస్తారు: GetObject(), ఉంది ReleaseObject().

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

క్రొత్త వస్తువును కేటాయించే బదులు, ఆబ్జెక్ట్ పూల్ నుండి ఒకదాన్ని అభ్యర్థించండి.

వస్తువును మళ్లీ ఉపయోగించే ముందు మీరు దాన్ని వదలారని మీరు నిర్ధారించుకోవాలి, ఎందుకంటే చాలా కొలనులలో గరిష్ట సంఖ్యలో ఖాళీ వస్తువులు ఉంటాయి, అవి చేతిలో దగ్గరగా ఉంటాయి. మీరు పూల్ నుండి 1,000 వస్తువులను తీసుకోవడానికి ప్రయత్నిస్తే, అది ఆరిపోతుంది మరియు ఇది సాధారణంగా డిమాండ్ ప్రకారం వాటిని కేటాయించడం ప్రారంభిస్తుంది, ఇది పూల్ యొక్క ప్రయోజనాన్ని ఓడిస్తుంది.

క్లిష్టమైన పనితీరు సందర్భాల్లో, ప్రత్యేకించి మీరు చాలాసార్లు పునరావృతమయ్యే డేటాతో పనిచేసేటప్పుడు, ఆబ్జెక్ట్ పూల్ నాటకీయంగా పనితీరును మెరుగుపరుస్తుంది. అయితే, ఇది బైండర్ కాదు మరియు మీరు వస్తువులను పూల్ చేయకూడదని చాలా సార్లు ఉన్నాయి. తో కేటాయింపులు new ఇప్పటికీ చాలా వేగంగా ఉన్నాయి, కాబట్టి మీరు చాలా తరచుగా మెమరీ భాగాలను కేటాయించడం లేదా అధిక-పనితీరు గల కన్స్ట్రక్టర్లతో వస్తువులను కేటాయించడం తప్ప, తరచుగా ఉపయోగించడం మంచిది new అనవసరంగా పూల్ చేయకుండా, ప్రత్యేకించి పూల్ కేటాయింపుకు అదనపు ఓవర్ హెడ్ మరియు సంక్లిష్టతను జోడిస్తుందని భావిస్తారు. ఒకే పూల్ వస్తువును కేటాయించడం కంటే ఒకే సాధారణ వస్తువును కేటాయించడం ఎల్లప్పుడూ వేగంగా ఉంటుంది; అవి చాలాసార్లు కేటాయించినప్పుడు పనితీరు వ్యత్యాసం సంభవిస్తుంది.

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

మీరు ఆబ్జెక్ట్ పూల్స్‌ను ఉపయోగించాలనుకుంటే, మైక్రోసాఫ్ట్ ఒక అమలును అందిస్తుంది Microsoft.Extensions.ObjectPool. మీరు దీన్ని మీరే అమలు చేయాలనుకుంటే, అది ఎలా పనిచేస్తుందో తనిఖీ చేయడానికి మీరు మూలాన్ని తెరవవచ్చు DefaultObjectPool. సాధారణంగా, మీరు ప్రతి రకానికి వేరే ఐటెమ్ పూల్ కలిగి ఉంటారు, పూల్‌లో ఉంచడానికి గరిష్ట సంఖ్యలో వస్తువులు ఉంటాయి.

Source link