Introductie van de wacht-, meldings- en meldingsmethoden

"Hallo Amigo!"

"Hallo Rishi!"

"Ik ga je kennis laten maken met de methodes wait , notification en notificationAll van de klasse Object."

"Vandaag maken we gewoon kennis met ze, maar we komen later terug en besteden hier meer tijd aan."

"Oké."

"Deze methoden zijn uitgevonden als onderdeel van het threadsynchronisatiemechanisme."

"Laat me je eraan herinneren dat Java een ingebouwd mechanisme heeft om de toegang tot gedeelde bronnen (objecten) van verschillende threads te controleren. Een thread kan aangeven dat een object bezig is en andere threads zullen moeten wachten tot het bezige object wordt vrijgegeven. "

"Ik herinner het me. Dat doe je met het gesynchroniseerde trefwoord."

"Juist. Meestal ziet de code er ongeveer zo uit:"

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

"Weet je nog hoe dat werkt?"

"Ja. Als twee threads tegelijkertijd de methode print() aanroepen, zal een van hen het blok met het label synchroon binnengaan en de monitor vergrendelen, waardoor de tweede thread wacht tot de monitor wordt vrijgegeven."

"Juist. Zodra een thread het blok gesynchroniseerd binnenkomt, wordt het monitorobject gemarkeerd als bezet en zullen andere threads moeten wachten tot het monitorobject wordt vrijgegeven. Hetzelfde monitorobject kan in verschillende delen van het programma worden gebruikt. "

"Trouwens, waarom heb je voor de naam monitor gekozen?"

"Een monitor is wat je gewoonlijk een object noemt dat de bezet- of vrijstatus opslaat."

"En dit is waar de wacht- en meldingsmethoden een rol gaan spelen."

"Eigenlijk zijn dit echt de enige twee methoden. De andere zijn slechts aanpassingen van deze methoden."

"Laten we nu eens kijken wat de wachtmethode is en waarom we die nodig hebben. "

"Soms zijn er situaties in een programma waarbij een thread een blok gesynchroniseerde code invoert en de monitor vergrendelt, maar niet verder kan gaan omdat er gegevens ontbreken. Een bestand dat moet worden verwerkt, is bijvoorbeeld nog niet klaar met downloaden of zoiets."

"We kunnen gewoon wachten tot het bestand is gedownload. Je kunt het gewoon controleren met een lus. Als het bestand nog niet is gedownload, slaap dan een seconde of zo en controleer opnieuw totdat het is gedownload."

"Iets zoals dit:"

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

"Maar in ons geval is dit soort wachten te duur. Omdat onze thread de monitor heeft vergrendeld, moeten andere threads ook wachten, ook al hebben ze misschien al de gegevens die ze nodig hebben."

"De methode wait() is uitgevonden om dit probleem op te lossen. Deze methode zorgt ervoor dat de thread de monitor vrijgeeft en vervolgens de thread "onderbreekt".

"Je kunt de wait-methode van een monitorobject alleen aanroepen als de monitor bezig is, dus alleen binnen een gesynchroniseerd blok. Wanneer dit gebeurt, stopt de thread tijdelijk en wordt de monitor vrijgegeven zodat andere threads deze kunnen gebruiken."

"Er zijn vaak gevallen waarin een thread een gesynchroniseerd blok binnengaat en wacht, waardoor de monitor wordt vrijgegeven."

"Dan komt er een tweede thread binnen die wordt opgeschort, dan een derde, enzovoort."

"En hoe wordt een thread hervat?"

"Daarvoor is er een tweede methode: verwittigen."

"U kunt de methode Notify / NotifyAll van een monitorobject alleen aanroepen als de monitor bezig is, dus alleen binnen een gesynchroniseerd blok. De methode NotifyAll maakt alle threads wakker die op dit monitorobject wachten."

"De meldingsmethode 'ontgrendelt' één willekeurige thread, maar de meldingAll- methode maakt alle "bevroren" threads van deze monitor vrij."

"Heel interessant. Dank je wel, Rishi."

"Er zijn ook aanpassingen aan de wait() methode:"

void wait(long timeout)

void wait(long timeout, int nanos)

"We noemen dit ook een wachttijd met een time-out. De methode werkt als een normale wachttijd, maar als de opgegeven tijd is verstreken en de thread niet is gewekt, wordt deze vanzelf wakker."