"వెయిట్-నోటిఫై-అందరికీ" వ్యూహం

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

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

"నేను ఒక చిన్న ఉదాహరణతో ప్రారంభిస్తాను. ఒక వెబ్‌సైట్ ద్వారా వినియోగదారులు సృష్టించిన వివిధ పనులను తప్పనిసరిగా నిర్వర్తించే సర్వర్ కోసం ఒక ప్రోగ్రామ్ ఉందని అనుకుందాం. వినియోగదారులు వివిధ సమయాల్లో వివిధ పనులను జోడించవచ్చు. పనులు వనరు-ఇంటెన్సివ్, కానీ మా సర్వర్ యొక్క 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 పద్ధతిని మేము కలిగి ఉన్నాము . జాబితాలో ఏదైనా కనిపించే వరకు థ్రెడ్ నిద్రపోతుంది (వేచి ఉంటుంది).

"జాబితాకు కొత్త టాస్క్‌ని జోడించడానికి మిమ్మల్ని అనుమతించే పుట్ మెథడ్ కూడా ఉంది . కొత్త టాస్క్ జోడించిన వెంటనే, నోటిఫైఅల్ మెథడ్ అంటారు. ఈ పద్ధతికి కాల్ చేయడం వల్ల getJob పద్ధతిలో నిద్రపోయిన అన్ని వర్కర్ థ్రెడ్‌లు మేల్కొంటాయి."

"నిరీక్షణ మరియు నోటిఫికేషన్ పద్ధతులు ఎలా పని చేస్తాయో మీరు మళ్లీ గుర్తుంచుకోగలరా?"

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

1) థ్రెడ్ నిద్రపోతుంది.

2) థ్రెడ్ తాత్కాలికంగా మ్యూటెక్స్‌ను విడుదల చేస్తుంది (అది మేల్కొనే వరకు).

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

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

1) ఈ మ్యూటెక్స్ ఆబ్జెక్ట్‌పై వేచి ఉన్న అన్ని థ్రెడ్‌లు మేల్కొన్నాయి.

2) ప్రస్తుత థ్రెడ్ సమకాలీకరించబడిన బ్లాక్ నుండి నిష్క్రమించిన తర్వాత, మేల్కొన్న థ్రెడ్‌లలో ఒకటి మ్యూటెక్స్‌ను పొందుతుంది మరియు దాని పనిని కొనసాగిస్తుంది. ఇది మ్యూటెక్స్‌ను విడుదల చేసినప్పుడు, మరొక మేల్కొన్న థ్రెడ్ మ్యూటెక్స్‌ను పొందుతుంది.

"ఇది బస్సును పోలి ఉంటుంది. మీరు ప్రవేశించి మీ ఛార్జీలు చెల్లించాలనుకుంటున్నారు, కానీ డ్రైవర్ లేడు. కాబట్టి మీరు «నిద్రపోతారు». చివరికి, బస్సు నిండిపోయింది, కానీ ఇప్పటికీ ఛార్జీని ఇవ్వడానికి ఎవరూ లేరు. తర్వాత డ్రైవర్. వచ్చి, "ఫేర్, ప్లీజ్" అని చెప్పాడు. మరియు ఇది ప్రారంభం..."

"ఆసక్తికరమైన పోలిక. అయితే బస్సు అంటే ఏమిటి?"

"జూలియో దీనిని వివరించాడు. 21వ శతాబ్దంలో ఈ విచిత్రమైన విషయాలు ఉపయోగించబడ్డాయి."