Bounded producer–consumer order queue

import java.util.ArrayDeque;
import java.util.Queue;
public class Main {
    static class OrderQueue {
        private final Queue<Integer> orders=new ArrayDeque<>();
        private final int capacity=3;private boolean closed;

Queue is the interface and ArrayDeque its concrete FIFO storage. OrderQueue keeps that storage private, capacity fixed at 3 and a closed flag for completion/cancellation.

        synchronized void put(int order) throws InterruptedException {
            while(orders.size()==capacity && !closed)wait();if(closed)return;
            orders.add(order);System.out.println("Produced order "+order);notifyAll();
        }

The synchronized put method waits in a while loop while full and open. On closure it returns without adding. Otherwise add the order, print its production and notify waiters. wait releases the monitor so a consumer can remove an item.

        synchronized Integer take() throws InterruptedException {
            while(orders.isEmpty() && !closed)wait();if(orders.isEmpty())return null;
            int order=orders.remove();System.out.println("Processed order "+order);notifyAll();return order;
        }

Wait while empty and open. If still empty after closure, return null as the end signal. Otherwise remove the oldest order, print it and notify producers. Integer permits null; primitive int would not.

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

close sets the shared flag and notifies all. Already queued items can still be removed; closure does not clear them.

    static class Producer extends Thread {
        final OrderQueue queue;Producer(OrderQueue q){queue=q;}
        @Override public void run(){try{for(int i=1;i<=6;i++)queue.put(i);}catch(InterruptedException e){Thread.currentThread().interrupt();}finally{queue.close();}}
    }

Producer stores the same queue reference. Its run sends orders 1–6. Catch restores interruption status; finally closes the queue whether production completed or was interrupted.

    static class Consumer extends Thread {
        final OrderQueue queue;Consumer(OrderQueue q){queue=q;}
        @Override public void run(){try{while(queue.take()!=null){/* Simulated processing. */}}catch(InterruptedException e){queue.close();Thread.currentThread().interrupt();}}
    }

Consumer repeatedly calls take until it returns null. An interruption closes the queue to wake other workers and restores the current thread’s flag. Printed producer/consumer interleaving can vary, while FIFO order is preserved.

    public static void main(String[] args) throws InterruptedException {
        OrderQueue queue=new OrderQueue();Thread producer=new Producer(queue),consumer=new Consumer(queue);producer.start();consumer.start();
        try{producer.join();consumer.join();}catch(InterruptedException e){queue.close();producer.interrupt();consumer.interrupt();throw e;}
    }
}

main creates one shared OrderQueue, starts a producer and a consumer, and waits for both. If main is interrupted, close the queue, interrupt workers and rethrow so blocked operations can terminate.