Ipinapakilala ang paghihintay, pag-abiso, at pag-abisoLahat ng mga pamamaraan

"Hi, Amigo!"

"Hi, Rishi!"

"Ipapakilala ko sa iyo ang paghihintay ng klase ng Object , notify , at notifyAll na mga pamamaraan."

"Ngayon ay makikilala lang natin sila, ngunit babalik tayo mamaya at maglalaan ng mas maraming oras para dito."

"Sige."

"Ang mga pamamaraang ito ay naimbento bilang bahagi ng mekanismo ng pag-synchronize ng thread."

"Hayaan mong ipaalala ko sa iyo na ang Java ay may built-in na mekanismo para sa pagkontrol ng access sa mga nakabahaging mapagkukunan (mga bagay) mula sa iba't ibang mga thread. Ang isang thread ay maaaring magpahayag na ang isang bagay ay abala, at ang ibang mga thread ay kailangang maghintay hanggang ang abalang bagay ay mailabas. "

"Naaalala ko. Ginagawa mo iyon gamit ang naka-synchronize na keyword."

"Tama. Karaniwan, ang code ay magmumukhang ganito:"

public void print()
{
 Object monitor = getMonitor();
 synchronized(monitor)
 {
  System.out.println("text");
 }
}

"Remember how that works?"

"Yep. Kung ang dalawang thread ay sabay-sabay na tumawag sa print() na paraan, isa sa mga ito ay papasok sa block na may label na naka-synchronize at i-lock ang monitor, na ginagawang kaya ang pangalawang thread ay maghihintay hanggang sa mailabas ang monitor."

"Tama. Kapag ang isang thread ay pumasok sa block na may label na naka-synchronize, ang monitor object ay mamarkahan bilang abala, at ang ibang mga thread ay mapipilitang maghintay para sa monitor object na ilabas. Ang parehong monitor object ay maaaring gamitin sa iba't ibang bahagi ng programa. "

"Nga pala, bakit pangalan monitor ang napili mo?"

"Ang monitor ay ang karaniwan mong tinatawag na isang bagay na nag-iimbak ng abala o libreng katayuan."

"At dito pumapasok ang mga paraan ng paghihintay at pag-abiso ."

"Actually, ito lang talaga ang dalawang method. Yung iba adaptations lang ng mga method na ito."

"Ngayon, ibalot natin ang ating mga ulo sa kung ano ang paraan ng paghihintay at kung bakit natin ito kailangan. "

"Minsan may mga sitwasyon sa isang programa kung saan ang isang thread ay pumapasok sa isang bloke ng naka-synchronize na code at nagla-lock sa monitor, ngunit hindi ito maaaring magpatuloy dahil ito ay nawawala ang ilang data. Halimbawa, ang isang file na kailangan nitong iproseso ay hindi pa tapos sa pag-download o may ganyan."

"Maaari lang nating hintayin na ma-download ang file. Maaari mo lamang itong suriin gamit ang isang loop. Kung hindi pa nagda-download ang file, matulog nang isang segundo o higit pa, at suriin muli hanggang sa ma-download ito."

"Isang bagay na tulad nito:"

while(!file.isDownloaded())
{
 Thread.sleep(1000);
}
processFile(file);

"Ngunit sa aming kaso, ang ganitong uri ng paghihintay ay masyadong mahal. Dahil ang aming thread ay naka-lock ang monitor, ang ibang mga thread ay napipilitang maghintay kahit na maaaring mayroon na sila ng data na kailangan nila."

"Ang wait() na paraan ay naimbento upang malutas ang problemang ito. Ang pamamaraang ito ay nagiging sanhi ng paglabas ng thread sa monitor at pagkatapos ay «suspindihin» ang thread.

"Maaari ka lamang tumawag sa paraan ng paghihintay ng isang monitor object kapag abala ang monitor, ibig sabihin, sa loob lamang ng isang naka-synchronize na bloke. Kapag nangyari ito, pansamantalang hihinto sa pagtakbo ang thread, at ilalabas ang monitor upang magamit ito ng ibang mga thread."

"May mga madalas na pagkakataon kung saan ang isang thread ay papasok sa isang naka-synchronize na bloke at tumawag ng paghihintay, kaya ilalabas ang monitor."

"Pagkatapos ay papasok ang isang pangalawang thread at masususpinde, pagkatapos ay isang pangatlo, at iba pa."

"At paano maipagpatuloy ang isang thread?"

"Para diyan, may pangalawang paraan: abisuhan."

"Maaari ka lamang tumawag sa isang monitor object's notify / notifyAll na mga pamamaraan kapag ang monitor ay abala, ibig sabihin, sa loob lamang ng isang naka-synchronize na bloke. Ang notifyAll na paraan ay gumising sa lahat ng mga thread na naghihintay sa monitor object na ito."

"Ang paraan ng pag-abiso ay 'nag-unfreeze' ng isang random na thread, ngunit ang paraan ng notifyAll ay nag-unfreeze ng lahat ng mga «frozen» na thread ng monitor na ito."

"Very interesting. Salamat, Rishi."

"Mayroon ding mga adaptasyon ng wait() na paraan:"

void wait(long timeout)

void wait(long timeout, int nanos)

"Tinatawag din namin itong paghihintay na may timeout. Ang pamamaraan ay gumagana tulad ng isang normal na paghihintay, ngunit kung ang tinukoy na oras ay lumipas at ang thread ay hindi pa nagising, ito ay nagigising mismo."