మెమరీ: ఎంత కేటాయించాలి మరియు మొత్తం ఎందుకు కాదు

ప్యానెల్‌లోని మెమరీ గ్రాఫ్ కొత్తవారిని భయపెడుతుంది: ఇది దాదాపు ఎప్పుడూ ఎక్కువగానే ఉంటుంది. ఇది Java యొక్క సాధారణ ప్రవర్తన.

దీన్ని ఎలా చదవాలి

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

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

కొరతకు సంకేతాలు

• లాగ్‌లో OutOfMemoryError — విశ్లేషణ.
• అప్‌టైమ్ పెరిగే కొద్దీ పెరిగే, కొన్ని సెకన్ల పాటు సాగే ఫ్రీజ్‌లు.
• రీస్టార్ట్ తర్వాత సర్వర్ సరిగ్గా నడుస్తుంది, సాయంత్రానికి నాసిరకం అవుతుంది.

లీక్

వినియోగం సరళంగా పెరుగుతూ, తగ్గకపోతే, దోషిని వెతకండి:

spark heapsummary

సాధారణంగా ఇది డేటాను పోగుచేసే ప్లగిన్, లేదా chunk loaders ఉన్న మోడ్ — Spark.

తాత్కాలిక పరిష్కారం రోజుకు ఒకసారి ఆటో-రీస్టార్ట్. శాశ్వత పరిష్కారం దోషిని కనుగొని అప్‌డేట్ చేయడం.

అంతా కేటాయించకండి

హీప్‌తో పాటు, ప్రాసెస్‌కు మెటాడేటా, థ్రెడ్‌లు మరియు బఫర్‌ల కోసం మెమరీ కావాలి, కంటైనర్‌కు సిస్టమ్ కోసం మెమరీ కావాలి. Millida ప్యానెల్ ప్లాన్ ప్రకారం హీప్ పరిమితులను సెట్ చేసి దీన్ని తనే లెక్కిస్తుంది — మీరు దీన్ని మాన్యువల్‌గా తాకాల్సిన అవసరం లేదు.

మీ ప్లాన్‌ను ఎప్పుడు మార్చాలి

సాధారణ ఆపరేషన్ సమయంలో గరిష్ఠ వినియోగం నిరంతరం పరిమితిని తాకుతూ, ప్రొఫైల్ లీక్‌ను చూపకపోతే — మీ ప్లాన్‌ను మార్చడం.