Implementing a Restaurant Ordering System with Semaphores

Welcome back! In our previous lesson, we examined how to simulate a car manufacturing line with multiple synchronized stages using Phaser and ExecutorService . That exercise helped illustrate the power of managing thread coordination in complex tasks. Today, we're shifting focus to another practical application of Java concurrency: implementing a restaurant ordering system using semaphores. This lesson aims to build on your concurrency knowledge, emphasizing resource management and thread synchronization.

What You'll Learn

In this lesson, you will explore: The concept of resource management through semaphores . How to handle concurrency when multiple threads access limited resources concurrently. Implementing a practical simulation of a real-life scenario where semaphores manage resource constraints effectively.

Recap: Using Semaphores and Their Role in Resource Management

You’ve previously learned about semaphores as a concurrency mechanism that helps control access to limited resources. A semaphore allows only a certain number of threads to access a resource at any given time. When a thread completes its task, it releases its hold on the semaphore, allowing another thread to proceed. This is particularly useful when simulating real-world systems where resources (like chefs in a restaurant) are limited. In this lesson, we will use semaphores to simulate a restaurant with multiple waiters taking orders and a limited number of chefs preparing the orders. The semaphore will ensure that only a specified number of orders are being prepared simultaneously, mimicking the constraint of having a limited number of chefs. The ExecutorService will manage the waiters, who submit orders to be processed.

Setting Up the Restaurant System

Let's first set up the basic structure of our system. We begin by initializing the semaphore and the executor service: Java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; public class RestaurantOrderingSystem {private final Semaphore chefSemaphore; private final ExecutorService executor; public RestaurantOrderingSystem(int numberOfChefs, int numberOfWaiters) {this.chefSemaphore = new Semaphore(numberOfChefs); this.executor = Executors.newFixedThreadPool(numberOfWaiters);}} In the above code, the Semaphore is initialized with the number of available chefs, controlling how many orders can be processed simultaneously. ExecutorService manages multiple threads representing waiters. Here’s what the key methods in the above snippet do: newFixedThreadPool() : This method creates a fixed pool of threads where the number of waiters taking orders is controlled. Semaphore : Manages the number of chefs available to process orders at a time, ensuring that only the allowed number of orders are prepared simultaneously.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Taking and Processing Orders

Now, let's move on to the logic for taking and processing orders. When an order is taken by a waiter, the system submits the task to the executor, and the semaphore controls access to the chefs who can prepare the orders.

Java

public void takeOrder(int orderNumber) {
    executor.submit(() -> {
        String waiterName = Thread.currentThread().getName();
        try {
            System.out.println(waiterName + " takes Order-" + orderNumber);
            chefSemaphore.acquire(); // Ensure a chef is available
            System.out.println("Chef starts preparing Order-" + orderNumber + " taken by " + waiterName);
            prepareOrder(orderNumber);
            System.out.println("Chef completes Order-" + orderNumber + " taken by " + waiterName);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println(waiterName + " was interrupted while taking Order-" + orderNumber);
        } finally {
            chefSemaphore.release(); // Release the chef for other orders
        }
    });
}

public void takeOrder(int orderNumber) {
    executor.submit(() -> {
        String waiterName = Thread.currentThread().getName();
        try {
            System.out.println(waiterName + " takes Order-" + orderNumber);
            chefSemaphore.acquire(); // Ensure a chef is available
            System.out.println("Chef starts preparing Order-" + orderNumber + " taken by " + waiterName);
            prepareOrder(orderNumber);
            System.out.println("Chef completes Order-" + orderNumber + " taken by " + waiterName);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println(waiterName + " was interrupted while taking Order-" + orderNumber);
        } finally {
            chefSemaphore.release(); // Release the chef for other orders
        }
    });
}

In the above code, the following actions occur:

Submitting the Task: The order is submitted to the executor via submit(), which ensures a thread is allocated to handle the task of taking and preparing the order.
Semaphore Acquisition: The semaphore’s acquire() method ensures that the number of available chefs is checked before the order is processed. If all chefs are busy, the thread will wait until a chef becomes available.
Releasing the Semaphore: After the order is prepared, the chef is "freed" with release(), allowing another order to be processed.

The chefSemaphore.acquire() and chefSemaphore.release() methods control access to the limited number of chefs (or resources) available for processing orders.

Preparing Orders and Shutting Down the System

Let’s now complete the logic for preparing the order and shutting down the executor when all tasks are finished:

Java

private void prepareOrder(int orderNumber) {
    try {
        Thread.sleep((long) (Math.random() * 3000 + 1000)); // Simulates order preparation time
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        System.err.println("Preparation of Order-" + orderNumber + " was interrupted.");
    }
}

public void shutdown() {
    executor.shutdown();
    try {
        if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
            executor.shutdownNow();
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                System.err.println("Executor did not terminate.");
            }
        }
    } catch (InterruptedException e) {
        executor.shutdownNow();
        Thread.currentThread().interrupt();
    }
    System.out.println("Restaurant is closed. All orders have been processed.");
}

private void prepareOrder(int orderNumber) {
    try {
        Thread.sleep((long) (Math.random() * 3000 + 1000)); // Simulates order preparation time
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        System.err.println("Preparation of Order-" + orderNumber + " was interrupted.");
    }
}

public void shutdown() {
    executor.shutdown();
    try {
        if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
            executor.shutdownNow();
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                System.err.println("Executor did not terminate.");
            }
        }
    } catch (InterruptedException e) {
        executor.shutdownNow();
        Thread.currentThread().interrupt();
    }
    System.out.println("Restaurant is closed. All orders have been processed.");
}

Here’s what happens:

prepareOrder(): This simulates the time it takes to prepare an order. The sleep() method introduces a delay that mimics the order preparation process.
shutdown(): This method gracefully shuts down the executor service once all orders are completed. It ensures that no further tasks are submitted, and it waits for all ongoing tasks to finish before shutting down completely.

The shutdown() method is critical for ensuring that all orders are processed before the system shuts down.

Implementing a Restaurant Ordering System with Semaphores