Sender–receiver chat with wait and notifyAll

public class Main {
    static class Chat {
        private String message; private boolean available,closed;

Chat stores a message, whether it is available, and whether the sender has closed. Both threads share this same Chat object.

        synchronized void send(String text) throws InterruptedException {
            while(available && !closed)wait();if(closed)return;
            message=text;System.out.println("Sender: "+text);available=true;notifyAll();
        }

The synchronized method waits while a previous message is available and the chat is open. If closed, return. Otherwise store and print the new text, mark it available and wake waiters. The sender cannot overwrite an unread message.

        synchronized String receive() throws InterruptedException {
            while(!available && !closed)wait();if(!available)return null;
            String result=message;System.out.println("Receiver: "+result);available=false;notifyAll();return result;
        }

Wait while the slot is empty and open. If no message remains after closure, return null. Otherwise copy the text, print it, clear available and notify the sender. A pending final message is still delivered after close.

        synchronized void close(){closed=true;notifyAll();}
    }

Setting closed under the same monitor makes the state change visible to synchronized send/receive calls. notifyAll lets them recheck their stop conditions.

    static class Sender extends Thread {
        final Chat chat;Sender(Chat chat){this.chat=chat;}
        @Override public void run(){
            try{for(String text:new String[]{"Hello","How are you?","Goodbye"})chat.send(text);}
            catch(InterruptedException e){Thread.currentThread().interrupt();}
            finally{chat.close();}
        }

Sender saves the shared reference. Its run sends the three strings in array order. On interruption it restores the flag, and finally closes the chat on either normal or interrupted completion.

    }
    static class Receiver extends Thread {
        final Chat chat;Receiver(Chat chat){this.chat=chat;}
        @Override public void run(){
            try{while(chat.receive()!=null){/* Continue until sender closes and slot drains. */}}
            catch(InterruptedException e){chat.close();Thread.currentThread().interrupt();}
        }
    }

Receiver saves the same Chat and repeats receive until null. If interrupted, it closes the chat and restores the flag. These braces finish run and the Receiver class.

    public static void main(String[] args) throws InterruptedException {
        Chat chat=new Chat();Thread sender=new Sender(chat),receiver=new Receiver(chat);sender.start();receiver.start();
        try{sender.join();receiver.join();}catch(InterruptedException e){chat.close();sender.interrupt();receiver.interrupt();throw e;}
    }
}

main starts sender and receiver on a shared Chat. join waits for both; an interrupted main closes shared state, interrupts both workers and rethrows. The monitor protocol, not timing delays, controls message handoff.