Java concurrency example-Synchronize resources using Semaphore

By | September 3, 2017
  • Semaphore is used to synchronize threads.
  • Semaphores are often used to restrict the number of threads than can access some (physical or logical) resource.
  • We will use binary semaphore to demonstrate the synchronization of shared resources.
    • What is binary Semaphore ?
      • A semaphore initialized to one, and which is used such that it only has at most one permit available. Only one permit is available to enter particular execution block.

1. Scenario: Synchronize resources using Semaphore (concurrency/example)

  • We have booking agent to tickets for passengers.
  • Suppose simultaneously more than one passengers approached booking agent to book their respective tickets.
  • Booking agent can entertain one passenger at a time (on).
  • We need to protect the concurrent access to book ticket(s), so that integrity of data is ensured.
    • We will use binary semaphore to protect shared resources.

2. Program: Synchronize resources using Semaphore (concurrency/example)

2.1 BookingAgent class:

  • BookingAgent class is responsible for booking tickets.
  • BookingAgent class implements Runnable interface.
package org.learn.sema;

public class BookingAgent implements Runnable {

    private Reservation reservation;

    public BookingAgent(Reservation reservation) {
        this.reservation = reservation;

    public void run() {
        System.out.println("Initiate booking for "+ Thread.currentThread().getName()); Object());
        System.out.println("Successfully booked ticket for "+ Thread.currentThread().getName());

2.2 Reservation class:

  • Reservation class is responsible for reserving the ticket(s).
  • We have used semaphore having permit count 1 (binary semaphore).
    • book method of reservation class make use of acquire & release method semaphore class.
package org.learn.sema;

import java.util.Random;
import java.util.concurrent.Semaphore;

import static java.lang.Thread.sleep;

public class Reservation {

    private Semaphore semaphore;
    private Random random = new Random();

    public Reservation() {
        semaphore = new Semaphore(1);

    public void book(Object personalInfo) {

        try {
            int duration = random.nextInt(100);
            System.out.printf("Time taken to book ticket for %s : %d\n",
                    Thread.currentThread().getName(), duration);
        } catch (InterruptedException e) {
        } finally {

2.3 SemaphoreExample class:

  • SemaphoreExample class contains main method to demonstrate semaphore construct.
  • We will simulate the booking of five passengers.
  • Five threads concurrency access the BookingAgent.
    • BookingAgent will internally using Semaphore to synchronize resources.
package org.learn.sema;

public class SemaphoreExample {
    public static void main(String[] args) throws InterruptedException {

        Reservation reservation = new Reservation();
        BookingAgent bookingAgent = new BookingAgent(reservation);

        for (int i = 1; i <= 5; i++) {
            Thread passenger = new Thread(bookingAgent, "Passenger "+i);

3. Output: Conurrency access to resources using Semaphore (java /example)

Initiate booking for Passenger 1
Initiate booking for Passenger 3
Initiate booking for Passenger 5
Initiate booking for Passenger 4
Initiate booking for Passenger 2
Time taken to book ticket for Passenger 1 : 47
Successfully booked ticket for Passenger 1
Time taken to book ticket for Passenger 3 : 60
Successfully booked ticket for Passenger 3
Time taken to book ticket for Passenger 5 : 78
Successfully booked ticket for Passenger 5
Time taken to book ticket for Passenger 4 : 64
Successfully booked ticket for Passenger 4
Time taken to book ticket for Passenger 2 : 67
Successfully booked ticket for Passenger 2