டெட்லாக் மற்றும் அதன் காரணங்கள்

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

"இன்று நான் உங்களுக்கு முட்டுக்கட்டை என்றால் என்ன என்று சொல்லப் போகிறேன்."

"ஏய், நீ ஏற்கனவே என்னிடம் அப்படி ஏதாவது சொல்லிவிட்டாய்."

"ஆம், நான் செய்தேன். ஆனால் இன்று நாம் தலைப்பை இன்னும் விரிவாகக் கருதுவோம்."

"எளிமையான வழக்கில், முட்டுக்கட்டை என்பது இரண்டு இழைகள் மற்றும் இரண்டு மியூடெக்ஸ் பொருள்களை உள்ளடக்கியது. பரஸ்பர பூட்டு ஏற்படும் போது:"

அ) ஒவ்வொரு நூலும் இரண்டு மியூடெக்ஸ்களையும் பெற வேண்டும்.

B)  முதல் இழை முதல் மியூடெக்ஸைப் பெற்றுள்ளது மற்றும் இரண்டாவது வெளியீட்டிற்காக காத்திருக்கிறது.

C)  இரண்டாவது த்ரெட் இரண்டாவது மியூடெக்ஸைப் பெற்று, முதல் நூல் வெளிவரக் காத்திருக்கிறது.

"இங்கே சில உதாரணங்கள்:

public class Student
{
 private ArrayList friends = new ArrayList();

 public synchronized ArrayList getFriends()
 {
  synchronized(friends)
  {
   return new ArrayList(friends);
  }
 }

 public synchronized int getFriendsCount()
 {
  return friends.size();
 }

 public int addFriend(Student student)
 {
  synchronized(friends)
  {
   friends.add(student)
   return getFriendsCount ();
  }
 }
}

"ஒரு நூல் getFriends முறையை அழைக்கிறது , இந்த பொருளின் மியூடெக்ஸைப் பெறுகிறது , பின்னர் நண்பர்கள் பொருளின் மியூடெக்ஸைப் பெறுகிறது."

"இதற்கிடையில், இரண்டாவது த்ரெட் addFriend முறையை அழைக்கிறது, நண்பர்கள் பொருளின் மியூடெக்ஸைப் பெறுகிறது, பின்னர் இந்த பொருளின் மியூடெக்ஸைப் பெறுகிறது ( getFriendsCount க்கு அழைப்பின் போது )."

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

"ஒரு புத்தகத்தில் நான் கண்ட மற்றொரு எளிய உதாரணத்தை மேற்கோள் காட்ட முடிவு செய்துள்ளேன்:"

class KnightUtil
{
 public static void kill(Knight knight1, Knight knight2)
 {
  synchronized(knight1)
  {
   synchronized(knight2)
   {
    knight2.live = 0;
    knight1.experience += 100;
   }
  }
 }
}

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

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

"இரண்டாவது நைட் டைஸ் (HP = 0)"

"முதல் நைட் 100 எக்ஸ்பி பெறுகிறது."

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

"முட்டுக்கட்டைப் பெற எங்களுக்கு பல முறைகள் தேவையில்லை என்று நீங்கள் சொல்கிறீர்களா?"

"சரி. சில சமயங்களில் த்ரெட்களை ஏற்படுத்துவதற்கு ஒரு எளிய முறை மட்டுமே தேவைப்படுகிறது, மேலும் முழு நிரலையும் செயலிழக்கச் செய்கிறது."

"ஆமாம், இந்த நிகழ்வு நான் நினைத்ததை விட அடிக்கடி நிகழும் என்று நினைக்கிறேன். நன்றி, எல்லி."