కరెన్సీ, బ్లాకింగ్ క్యూలు (జావా 7)

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

"హాయ్, కిమ్!"

"ఈ రోజు, నేను మీకు కరెన్సీ గురించి చెప్పబోతున్నాను."

" కరెన్సీ అనేది జావా క్లాస్ లైబ్రరీ, ఇది బహుళ థ్రెడ్‌ల నుండి పని కోసం ఆప్టిమైజ్ చేయబడిన ప్రత్యేక తరగతులను కలిగి ఉంటుంది. ఇది చాలా ఆసక్తికరమైన మరియు విస్తృతమైన అంశం. అయితే ఈ రోజు మనం పరిచయం చేయబోతున్నాం. ప్యాకేజీని java.util అంటారు. ఉమ్మడి ప్యాకేజీ. నేను మీకు కొన్ని ఆసక్తికరమైన తరగతుల గురించి చెబుతాను."

" అణు రకాలు. "

"కౌంట్++ కూడా థ్రెడ్-సేఫ్ ఆపరేషన్ కాదని మీకు ఇప్పటికే తెలుసు. వేరియబుల్‌ను 1తో పెంచినప్పుడు, మూడు కార్యకలాపాలు వాస్తవానికి జరుగుతాయి. ఫలితంగా, వేరియబుల్ మార్చబడినప్పుడు వైరుధ్యం ఉండవచ్చు."

"అవును, ఎల్లీ నాకు చాలా కాలం క్రితం చెప్పింది:"

register1 = count;
register1++;
count = register1;

register2 = count;
register2++;
count = register2;

register1 = count;
register2 = count;
register2++;
count = register2;
register1++;
count = register1;

"సరిగ్గా. జావా ఈ కార్యకలాపాలను ఒకటిగా నిర్వహించడానికి డేటా రకాలను జోడించింది, అంటే పరమాణుపరంగా (ఒక పరమాణువు విడదీయరానిది)."

"ఉదాహరణకు, జావాలో అటామిక్ ఇంటెజర్, అటామిక్ బూలియన్, అటామిక్డబుల్ మొదలైనవి ఉన్నాయి."

"మనం ఒక "కౌంటర్" తరగతిని తయారు చేయాలని అనుకుందాం:"

class Counter
{
 private int c = 0;

 public void increment()
 {
  c++;
 }

 public void decrement()
 {
  c--;
 }

 public int value()
 {
  return c;
 }
}

"మీరు ఈ తరగతి థ్రెడ్‌లోని వస్తువులను ఎలా సురక్షితంగా చేస్తారు?"

"సరే, నేను అన్ని పద్ధతులను సమకాలీకరించి, దానితో పూర్తి చేస్తాను:"

class synchronized Counter
{
 private int c = 0;

 public synchronized void increment()
 {
  c++;
 }

 public synchronized void decrement()
 {
  c--;
 }

 public synchronized int value()
 {
  return c;
 }
}

"మంచి పని. కానీ, మనం పరమాణు రకాలను ఉపయోగిస్తే ఎలా ఉంటుంది:"

class AtomicCounter
{
 private AtomicInteger c = new AtomicInteger(0);

 public void increment()
 {
  c.incrementAndGet();
 }

 public void decrement()
 {
  c.decrementAndGet();
 }

 public int value()
 {
  return c.get();
 }
}

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

"సరే, చిన్న తేడానా?"

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

"నేను అంగీకరిస్తున్నాను. అది అర్ధమే."

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

"అర్థమైంది. స్ట్రింగ్ మరియు స్ట్రింగ్‌బఫర్ లాగానే ."

"అవును, అలాంటిదే."

" థ్రెడ్-సురక్షిత సేకరణలు. "

"అటువంటి సేకరణకు ఉదాహరణగా, నేను ConcurrentHashMapని అందించవచ్చు. మీరు HashMap థ్రెడ్-సురక్షితంగా ఎలా తయారు చేస్తారు?"

"దాని అన్ని పద్ధతులను సమకాలీకరించాలా?"

"ఖచ్చితంగా, కానీ ఇప్పుడు మీరు అలాంటి SynchronizedHashMapని కలిగి ఉన్నారని ఊహించుకోండి మరియు డజన్ల కొద్దీ థ్రెడ్‌లు దానిని యాక్సెస్ చేస్తున్నాయి. మరియు సెకనుకు వంద సార్లు మ్యాప్‌కి కొత్త ఎంట్రీ జోడించబడుతుంది మరియు ప్రక్రియలో మొత్తం వస్తువు చదవడం మరియు వ్రాయడం కోసం లాక్ చేయబడుతుంది."

"సరే, ఇది ప్రామాణిక విధానం. మీరు ఏమి చేయగలరు?"

"జావా సృష్టికర్తలు కొన్ని మంచి విషయాలతో ముందుకు వచ్చారు."

"మొదట, వారు ఒకే బ్లాక్‌లో ConcurrentHashMapలో డేటాను నిల్వ చేస్తారు, కానీ దానిని 'బకెట్లు' అని పిలిచే భాగాలుగా విభజిస్తారు. మరియు ఎవరైనా ConcurrentHashMapలో డేటాను మార్చినప్పుడు, మేము మొత్తం వస్తువును కాకుండా యాక్సెస్ చేయబడిన బకెట్‌ను మాత్రమే లాక్ చేస్తాము. పదాలు, అనేక థ్రెడ్‌లు వస్తువును ఏకకాలంలో మార్చగలవు."

"రెండవది, మీరు జాబితా/మ్యాప్‌లోని ఎలిమెంట్‌లను మళ్లించలేరని మరియు అదే సమయంలో జాబితాను మార్చలేరని మీకు గుర్తుందా? అలాంటి కోడ్ మినహాయింపుని ఇస్తుంది:"

HashMap<String, Integer> map = new HashMap<String, Integer>();

for (String key: map.keySet())
{
 if (map.get(key) == 0)
  map.remove(key);
}

"కానీ ConcurrentHashMapలో, మీరు వీటిని చేయవచ్చు:"

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();

for (String key: map.keySet())
{
 if (map.get(key) == 0)
  map.remove(key);
}

"కాకరెంట్ ప్యాకేజీ అనేక ప్రయోజనాలను కలిగి ఉంది. ఈ తరగతులను ఉపయోగించడానికి మనం బాగా అర్థం చేసుకోవాలి."

"నేను చూస్తున్నాను. ధన్యవాదాలు, కిమ్. ఇవి నిజంగా ఆసక్తికరమైన తరగతులు. ఏదో ఒక రోజు నేను వాటిని ఒక ఘనాపాటీగా నేర్చుకుంటానని ఆశిస్తున్నాను."