Using Semaphores for Resource Management

Introduction to Using Semaphores for Resource Management

Welcome to the first lesson of our Advanced Concurrency Utilities course! In this lesson, we’ll explore semaphores, a critical tool for managing resource access in multithreaded environments. Semaphores help control the number of threads that can access shared resources, ensuring efficiency and preventing resource exhaustion. You’ll learn how semaphores work and how to implement them in real-world scenarios.

What You'll Learn

In this lesson, you'll gain a comprehensive understanding of: Counting semaphores and how to use them for controlled access to shared resources. How to acquire and release permits using methods like acquire() and release() . How semaphores can help you prevent resource exhaustion without busy waiting. By the end of the lesson, you’ll be able to use semaphores to efficiently manage resources in your applications.

Understanding Semaphores

A semaphore is a shared integer variable that helps control access to a resource by multiple threads. At its core, a semaphore's primary function is to allow or deny access to shared resources based on the availability of "permits." A semaphore tracks the number of available permits and blocks threads if none are available, ensuring that only a certain number of threads can access the resource at any given time. The main purposes of semaphores include: Resource Management : Semaphores limit the number of threads that can access a particular resource (such as a database connection or a file) concurrently. This prevents resource exhaustion. Non-Busy Waiting : One of the key advantages of semaphores is that they do not require "busy waiting." Instead of constantly checking whether the resource is available (which wastes CPU cycles), threads can block and wait for a permit to become available, allowing other threads to run. Signaling Between Threads : Semaphores can also be used to signal between threads — for example, one thread can release a semaphore permit when it's done, and another thread can acquire it to proceed. A semaphore is initialized with a number of permits (representing available resources). Every time a thread tries to access a resource, it must first acquire a permit by calling acquire() . If no permits are available, the thread will block until one is released. Once a thread is done with the resource, it releases the permit using release() .

Join the 1M+ learners on CodeSignal

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

Creating Print Jobs

Now, let’s define the jobs that will use the PrintQueue. The Job class implements the Runnable interface, allowing multiple threads to run concurrently. Each thread represents a print job that acquires a printer, prints a document, and releases the printer afterward.

Java

public class Job implements Runnable {
    private final PrintQueue printQueue;

    public Job(PrintQueue printQueue) {
        this.printQueue = printQueue;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ": Going to print a document");
        try {
            // Acquire a printer before starting the print job
            printQueue.acquirePrinter();
            System.out.println(Thread.currentThread().getName() + ": Acquired a printer. Available printers: " + printQueue.getAvailablePrinters());

            // Simulate the printing job
            printQueue.printJob();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // Release the printer after printing
            printQueue.releasePrinter();
            System.out.println(Thread.currentThread().getName() + ": Finished printing. Available printers: " + printQueue.getAvailablePermits());
        }
    }
}

public class Job implements Runnable {
    private final PrintQueue printQueue;

    public Job(PrintQueue printQueue) {
        this.printQueue = printQueue;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + ": Going to print a document");
        try {
            // Acquire a printer before starting the print job
            printQueue.acquirePrinter();
            System.out.println(Thread.currentThread().getName() + ": Acquired a printer. Available printers: " + printQueue.getAvailablePrinters());

            // Simulate the printing job
            printQueue.printJob();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // Release the printer after printing
            printQueue.releasePrinter();
            System.out.println(Thread.currentThread().getName() + ": Finished printing. Available printers: " + printQueue.getAvailablePermits());
        }
    }
}

In the run() method, the thread begins by announcing it will print a document. It then calls acquirePrinter(), which blocks until a permit (printer) is available. Once a printer is acquired, the thread simulates the printing process by calling printJob(). After the job is completed, the printer is released using releasePrinter(), making it available for other threads. This ensures that no more threads than available printers can proceed at once.

Introduction to Using Semaphores for Resource Management

What You'll Learn

Understanding Semaphores

Join the 1M+ learners on CodeSignal

Setting Up the Print Queue

Acquiring and Releasing Printers

Printing Jobs

Creating Print Jobs

Running the Print Queue

Why It Matters