கன்கரன்சி, பிளாக்கிங் வரிசைகள் (ஜாவா 7)

"வணக்கம், அமிகோ!"

"வணக்கம், கிம்!"

"இன்று, நான் உங்களுக்கு ஒருங்கிணைவைப் பற்றி சொல்லப் போகிறேன்."

" Concurrency என்பது ஜாவா கிளாஸ் லைப்ரரி ஆகும், இதில் பல நூல்களில் இருந்து வேலை செய்ய உகந்ததாக இருக்கும் சிறப்பு வகுப்புகள் உள்ளன. இது மிகவும் சுவாரஸ்யமான மற்றும் விரிவான தலைப்பு. ஆனால் இன்று நாம் ஒரு அறிமுகத்தைப் பெறப் போகிறோம். தொகுப்பு 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();
 }
}

"உங்கள் வகுப்பு மற்றும் எனது வகுப்பு இரண்டும் ஒரே மாதிரியாக வேலை செய்கின்றன, ஆனால் ஒரு அணுஇண்டீஜர் கொண்ட வகுப்பு வேகமாக வேலை செய்கிறது."

"சரி, சின்ன வித்தியாசமா?"

ஆம் அத்தகைய வகைகள் உள்ளன என்பதை அறிய. நீங்கள் அவற்றை தீவிரமாகப் பயன்படுத்தாவிட்டாலும், அவை பயன்படுத்தப்படும் குறியீட்டில் நீங்கள் இயங்குவதற்கான வாய்ப்பு எப்போதும் உள்ளது."

"நான் ஒப்புக்கொள்கிறேன், அது அர்த்தமுள்ளதாக இருக்கிறது."

"இதன் மூலம், அணு வகைகள் மாறாதவை என்பதை நீங்கள் கவனித்தீர்களா ? நிலையான முழு எண் வகுப்பிற்கு மாறாக , AtomicInteger ஆனது அதன் உள் நிலையை மாற்றுவதற்கான முறைகளைக் கொண்டுள்ளது."

"கிடைத்தது. ஸ்டிரிங் மற்றும் ஸ்டிரிங்பஃபர் போலவே ."

"ஆமாம், அப்படி ஒன்று."

" த்ரெட்-பாதுகாப்பான சேகரிப்புகள். "

"அத்தகைய சேகரிப்புக்கு உதாரணமாக, நான் ConcurrentHashMap ஐ வழங்கலாமா. HashMap த்ரெட்-பாதுகாப்பானது எப்படி?"

"அதன் அனைத்து முறைகளையும் ஒத்திசைக்க வேண்டுமா?"

"நிச்சயமாக, ஆனால் இப்போது உங்களிடம் இதுபோன்ற ஒரு ஒத்திசைக்கப்பட்ட ஹாஷ்மேப் இருப்பதாகவும், அதை அணுகும் டஜன் கணக்கான த்ரெட்கள் இருப்பதாகவும் கற்பனை செய்து பாருங்கள். மேலும் ஒரு நொடிக்கு நூறு முறை புதிய பதிவுகள் வரைபடத்தில் சேர்க்கப்படும், மேலும் செயல்பாட்டில் முழுப் பொருளும் படிக்கவும் எழுதவும் பூட்டப்பட்டிருக்கும்."

"சரி, இதுதான் நிலையான அணுகுமுறை. நீங்கள் என்ன செய்ய முடியும்?"

"ஜாவாவின் படைப்பாளிகள் சில அருமையான விஷயங்களைக் கொண்டு வந்தனர்."

"முதலில், அவர்கள் கான்கரன்ட் ஹாஷ்மேப்பில் தரவை ஒரே தொகுதியில் சேமிக்கிறார்கள், ஆனால் அதை 'பக்கெட்டுகள்' எனப்படும் பகுதிகளாகப் பிரிக்கிறார்கள். மேலும் யாராவது கான்கரன்ட் ஹாஷ்மேப்பில் தரவை மாற்றினால், முழு பொருளையும் விட, அணுகப்படும் வாளியை மட்டுமே பூட்டுகிறோம். மற்றவற்றில் வார்த்தைகள், பல நூல்கள் ஒரே நேரத்தில் பொருளை மாற்றும்."

"இரண்டாவதாக, பட்டியல்/வரைபடத்தின் கூறுகளை மீண்டும் மீண்டும் செய்ய முடியாது மற்றும் பட்டியலை ஒரே நேரத்தில் மாற்ற முடியாது என்பதை நினைவில் கொள்கிறீர்களா? அத்தகைய குறியீடு விதிவிலக்கை அளிக்கும்:"

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);
}

"ஒத்தான தொகுப்பு பல நன்மைகளைக் கொண்டுள்ளது. அவற்றைப் பயன்படுத்துவதற்கு இந்த வகுப்புகளை நாம் நன்றாகப் புரிந்து கொள்ள வேண்டும்."

"நான் பார்க்கிறேன். நன்றி, கிம். இவை உண்மையிலேயே சுவாரசியமான வகுப்புகள். ஒரு நாள் நான் ஒரு கலைஞனைப் போல அவற்றில் தேர்ச்சி பெறுவேன் என்று நம்புகிறேன்."