How does the while loop inside writer and reader class works here ? How does the thread change the `empty` variable?

I was learning Multithreading in java and came across this example--

package com.practice.multithreading;
import java.util.Random;
public class DeadlockMain {
public static void main(String[] args) {
Message message = new Message();
(new Thread(new Writer(message))).start();
(new Thread(new Reader(message))).start();
}
}
class Message {
private String message;
private boolean empty = true;
public synchronized String read() {
while(empty) {
try {
wait();
} catch(InterruptedException e) {
}
}
empty = true;
notifyAll();
return message;
}
public synchronized void write(String message) {
while(!empty) {
try {
wait();
} catch(InterruptedException e) {
}
}
empty = false;
this.message = message;
notifyAll();
}
}
class Writer implements Runnable {
private Message message;
public Writer(Message message) {
this.message = message;
}
public void run() {
String messages[] = {
"Humpty Dumpty sat on a wall",
"Humpty Dumpty had a great fall",
"All the king's horses and all the king's men",
"Couldn't put Humpty together again"
};
Random random = new Random();
for(int i=0; i<messages.length; i++) {
message.write(messages[i]);
try {
Thread.sleep(random.nextInt(2000));
} catch(InterruptedException e) {
}
}
message.write("Finished");
}
}
class Reader implements Runnable {
private Message message;
public Reader(Message message) {
this.message = message;
}
public void run() {
Random random = new Random();
for(String latestMessage = message.read(); !latestMessage.equals("Finished");
latestMessage = message.read()) {
System.out.println(latestMessage);
try {
Thread.sleep(random.nextInt(2000));
} catch(InterruptedException e) {
}
}
}
}

My understanding is--

• When a thread is calling the write method,

• the empty variable is true so while(!true) => false ,

• skips while loop sets empty=false,

• then this.message=message,

• next iteration of for loop,while(!false)=> true

• No the control is inside the while loop,

  Now i cannot find anywhere inside this loop/or in the thread calling method empty variable being set to true so that control comes out of while loop.
  So how does the threads change the empty variable and write and read the messages??

Can anyone pls explain me a few iterations of this code?

It would be of a great help to me.
Thanks in advance!

You can think of the message class as a single-message buffer. When you write a message to it, it becomes full and cannot accept new messages until the message is read. Similarly, if you read the message when it is empty, it waits until someone writes to it.

Message instances start empty, so when you write to it, it skips the while loop, sets the message, and notifies any waiting readers.

Another write before the read now waits at the while loop, because empty is false.

If you read the message from a thread and if the message is nonempty, then read skips the while loop, sets empty to true, and notifies any waiting writers.

When the writer wakes up, it sees that empty is true, writes the message, and sets empty to false again.