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

"హాయ్, ఎల్లీ!"

"నేను మీకు అస్థిర మాడిఫైయర్ గురించి చెప్పాలనుకుంటున్నాను. అది ఏమిటో మీకు తెలుసా?"

"ఏదో థ్రెడ్‌లతో సంబంధం ఉంది. నాకు సరిగ్గా గుర్తులేదు."

"అయితే వినండి. మీ కోసం ఇక్కడ కొన్ని సాంకేతిక వివరాలు ఉన్నాయి:"

"కంప్యూటర్‌కు రెండు రకాల మెమరీ ఉంటుంది: గ్లోబల్ (సాధారణ) మెమరీ మరియు మెమరీని ప్రాసెసర్‌లో నిర్మించారు. అంతర్నిర్మిత ప్రాసెసర్ మెమరీ రిజిస్టర్‌లుగా విభజించబడింది, మొదటి-స్థాయి కాష్ (L1), రెండవ-స్థాయి కాష్ (L2), మరియు మూడవ-స్థాయి (L3)."

"ఈ రకమైన మెమరీ వేర్వేరు వేగాన్ని కలిగి ఉంటుంది. వేగవంతమైన మరియు అతిచిన్న మెమరీ రిజిస్టర్లు, తర్వాత ప్రాసెసర్ కాష్ (L1, L2, L3), మరియు చివరకు గ్లోబల్ మెమరీ (నెమ్మదైనది)."

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

Java webinar

"ఈ ప్రక్రియను ఎలాగైనా నియంత్రించవచ్చా?"

"నిజంగా కాదు. పని అంతా జావా మెషీన్ ద్వారా జరుగుతుంది. పనితీరును ఆప్టిమైజ్ చేసే విషయంలో ఇది చాలా తెలివైనది."

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

"సరే, అప్పుడు ఏమి చేయవచ్చు?"

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

public volatile int count = 0;

"ఓహ్, నాకు గుర్తుంది. మీరు ఇప్పటికే దీని గురించి ప్రస్తావించారు. ఇది నాకు ముందే తెలుసు."

"తప్పకుండా చేస్తా. కానీ నేను చెప్పగానే నీకు గుర్తు వచ్చింది."

"ఏర్, నేను కొంచెం మర్చిపోయాను."

"పునరావృతం నేర్చుకునే తల్లి!"

"అస్థిర మాడిఫైయర్ గురించి ఇక్కడ కొన్ని కొత్త వాస్తవాలు ఉన్నాయి. అస్థిర మాడిఫైయర్ వేరియబుల్ సురక్షితంగా చదవబడుతుంది మరియు వ్రాయబడుతుంది అని మాత్రమే హామీ ఇస్తుంది. ఇది సురక్షితంగా మార్చబడుతుందని ఇది హామీ ఇవ్వదు."

"తేడా ఏమిటి?"

"వేరియబుల్ ఎలా మార్చబడిందో చూడండి:"

కోడ్ నిజంగా ఏమి జరుగుతుంది: వివరణ 
count++
 
register = count;

register = register+1;

count = register;
 దశ 1.
వేరియబుల్ కౌంట్ విలువ గ్లోబల్ మెమరీ నుండి ప్రాసెసర్ రిజిస్టర్‌కి కాపీ చేయబడింది.

దశ 2.
ప్రాసెసర్ లోపల, రిజిస్టర్ వేరియబుల్ 1 ద్వారా పెంచబడుతుంది.

దశ 3.
వేరియబుల్ విలువ ప్రాసెసర్ నుండి గ్లోబల్ మెమరీకి కాపీ చేయబడుతుంది.

"వావ్! కాబట్టి, అన్ని వేరియబుల్స్ ప్రాసెసర్‌లో మాత్రమే మార్చబడతాయి?"

"అవును."

"మరియు విలువలు ముందుకు వెనుకకు కాపీ చేయబడతాయి: మెమరీ నుండి ప్రాసెసర్ మరియు వెనుకకు?"

"అవును."

"వేరియబుల్ కౌంట్‌ను యాక్సెస్ చేసినప్పుడు అది మెమరీ (స్టెప్ 1) నుండి రీడ్ చేయబడుతుందని అస్థిర మాడిఫైయర్ హామీ ఇస్తుంది మరియు థ్రెడ్ కొత్త విలువను కేటాయించాలనుకుంటే, అది ఖచ్చితంగా గ్లోబల్ మెమరీలో ఉంటుంది (స్టెప్ 3)."

"కానీ జావా మెషీన్ 1 మరియు 3 దశల మధ్య ఎటువంటి థ్రెడ్ మారడం లేదని హామీ ఇవ్వదు."

"కాబట్టి, వేరియబుల్‌ను 1 ద్వారా పెంచడం వాస్తవానికి మూడు కార్యకలాపాలు?"

"అవును."

"మరియు రెండు థ్రెడ్‌లు ఏకకాలంలో కౌంట్++ని అమలు చేయాలనుకుంటే, అవి ఒకదానితో ఒకటి జోక్యం చేసుకోగలవా?"

"అవును, తనిఖీ చేయండి:"

థ్రెడ్ 1 థ్రెడ్ 2 ఫలితం 
register1 = count;
register1++;
count = register1;
 
register2 = count;
register2++;
count = register2;
 
register1 = count;
register2 = count;
register2++;
count = register2;
register1++;
count = register1;

"కాబట్టి, మీరు వేరియబుల్‌ని యాక్సెస్ చేయవచ్చు, కానీ దానిని మార్చడం ఇంకా ప్రమాదకరమేనా?"

"సరే, మీరు దానిని మార్చవచ్చు, జాగ్రత్తగా ఉండండి ☺"

"ఎలా?"

" సింక్రొనైజ్డ్  మా బెస్ట్ ఫ్రెండ్."

"అలాగా."