"அனைவருக்கும் காத்திருக்க-அறிவிக்கவும்" உத்தி

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

"காத்திருப்பு-அறிவிப்பு தொடர்பாக உங்களுடன் ஆழமாகச் செல்ல விரும்புகிறேன். காத்திருப்பு-அறிவிப்பு முறைகள் த்ரெட்களை தொடர்புகொள்வதற்கான வசதியான வழிமுறையை வழங்குகின்றன. நூல் தொடர்புக்கான சிக்கலான உயர்-நிலை வழிமுறைகளை உருவாக்கவும் அவை பயன்படுத்தப்படலாம்."

"நான் ஒரு சிறிய உதாரணத்துடன் தொடங்குகிறேன். ஒரு இணையதளம் மூலம் பயனர்களால் உருவாக்கப்பட்ட பல்வேறு பணிகளைச் செய்ய வேண்டிய ஒரு சேவையகத்திற்கான ஒரு நிரல் எங்களிடம் உள்ளது என்று வைத்துக்கொள்வோம். பயனர்கள் வெவ்வேறு நேரங்களில் பல்வேறு பணிகளைச் சேர்க்கலாம். பணிகள் வளம் மிகுந்தவை, ஆனால் எங்கள் சேவையகத்தின் 8 -core செயலி சமாளிக்கும். சர்வரில் நாம் எவ்வாறு பணிகளைச் செய்ய வேண்டும்?"

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

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

"பணிப் பொருளின் உதாரணம் தர முடியுமா?"

"பாருங்கள்:"

class Factorial implements Runnable
{
 public int n = 0;
 public long result = 1;

 public Factorial (int n)
 {
  this.n = n;
 }

 public void run()
 {
  for (int i = 2; i <= n; i++)
   result *= i;
 }
}

"இதுவரை மிகவும் நல்ல."

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

"இது நூல்-பாதுகாப்பானதாக இருக்க வேண்டும். இது பயனர்களிடமிருந்து பெறும் ஒரு நூலால் பணிப் பொருள்களுடன் ஏற்றப்படுகிறது, பின்னர் பணிகள் பணியாளர் நூல்களால் எடுக்கப்படும்."

"ஆமாம். சில நேரம் டாஸ்க் இல்லாமல் போனால் என்ன செய்வது?"

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

"அது சரி. இப்போது இதையெல்லாம் ஒரே வரிசையில் கட்டலாம் என்று கற்பனை செய்து பாருங்கள். பாருங்கள்:"

public class JobQueue
{
 ArrayList jobs = new ArrayList();

 public synchronized void put(Runnable job)
 {
  jobs.add(job);
  this.notifyAll();
 }

 public synchronized Runnable getJob()
 {
  while (jobs.size() == 0)
   this.wait();

  return jobs.remove(0);
 }
}

"பணிப் பட்டியல் காலியாக உள்ளதா என்பதைச் சரிபார்க்கும் ஒரு getJob முறை எங்களிடம் உள்ளது . பட்டியலில் ஏதாவது தோன்றும் வரை நூல் உறங்கச் செல்லும் (காத்திருக்கும்).

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

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

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

1) நூல் தூங்குகிறது.

2) நூல் தற்காலிகமாக மியூடெக்ஸை வெளியிடுகிறது (அது எழுந்திருக்கும் வரை).

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

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

1) இந்த மியூடெக்ஸ் பொருளில் காத்திருக்கும் அனைத்து நூல்களும் விழித்தெழுகின்றன.

2) தற்போதைய நூல் ஒத்திசைக்கப்பட்ட தொகுதியிலிருந்து வெளியேறியதும், விழித்தெழுந்த நூல்களில் ஒன்று மியூடெக்ஸைப் பெற்று அதன் வேலையைத் தொடரும். அது மியூடெக்ஸை வெளியிடும்போது, ​​மற்றொரு விழித்தெழுந்த நூல் மியூடெக்ஸைப் பெறுகிறது.

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

"சுவாரஸ்யமான ஒப்பீடு. ஆனால் பஸ் என்றால் என்ன?"

"ஜூலியோ இதை விளக்கினார். 21 ஆம் நூற்றாண்டில் இந்த வித்தியாசமான விஷயங்கள் பயன்படுத்தப்பட்டன."