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

Java

import java.util.concurrent.Semaphore;

public class PrintQueue {
    private final Semaphore semaphore;

    public PrintQueue(int numberOfPrinters) {
        semaphore = new Semaphore(numberOfPrinters);
    }

import java.util.concurrent.Semaphore;

public class PrintQueue {
    private final Semaphore semaphore;

    public PrintQueue(int numberOfPrinters) {
        semaphore = new Semaphore(numberOfPrinters);
    }

Java

    public void acquirePrinter() throws InterruptedException {
        semaphore.acquire();
    }

    public void releasePrinter() {
        semaphore.release();
    }

    public void acquirePrinter() throws InterruptedException {
        semaphore.acquire();
    }

    public void releasePrinter() {
        semaphore.release();
    }

Java

    public void printJob() {
        try {
            long duration = (long) (Math.random() * 5000);
            System.out.println(Thread.currentThread().getName() +
                ": Printing a Job for " + (duration / 1000) + " seconds");

            Thread.sleep(duration);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public int getAvailablePrinters() {
        return semaphore.availablePermits();
    }

    public void printJob() {
        try {
            long duration = (long) (Math.random() * 5000);
            System.out.println(Thread.currentThread().getName() +
                ": Printing a Job for " + (duration / 1000) + " seconds");

            Thread.sleep(duration);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public int getAvailablePrinters() {
        return semaphore.availablePermits();
    }

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());
        }
    }
}

Java

public class Main {
    public static void main(String[] args) {
        int numberOfPrinters = 2;
        PrintQueue printQueue = new PrintQueue(numberOfPrinters);

        Thread[] threads = new Thread[5];

        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(new Job(printQueue), "Thread " + (i + 1));
        }

        for (Thread thread : threads) {
            thread.start();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int numberOfPrinters = 2;
        PrintQueue printQueue = new PrintQueue(numberOfPrinters);

        Thread[] threads = new Thread[5];

        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(new Job(printQueue), "Thread " + (i + 1));
        }

        for (Thread thread : threads) {
            thread.start();
        }
    }
}

Java

import java.util.concurrent.Semaphore;

public class PrintQueue {
    private final Semaphore semaphore;

    public PrintQueue(int numberOfPrinters) {
        semaphore = new Semaphore(numberOfPrinters);
    }

Java

    public void acquirePrinter() throws InterruptedException {
        semaphore.acquire();
    }

    public void releasePrinter() {
        semaphore.release();
    }

Java

    public void printJob() {
        try {
            long duration = (long) (Math.random() * 5000);
            System.out.println(Thread.currentThread().getName() +
                ": Printing a Job for " + (duration / 1000) + " seconds");

            Thread.sleep(duration);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public int getAvailablePrinters() {
        return semaphore.availablePermits();
    }

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());
        }
    }
}

Java

public class Main {
    public static void main(String[] args) {
        int numberOfPrinters = 2;
        PrintQueue printQueue = new PrintQueue(numberOfPrinters);

        Thread[] threads = new Thread[5];

        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(new Job(printQueue), "Thread " + (i + 1));
        }

        for (Thread thread : threads) {
            thread.start();
        }
    }
}

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