Java concurrency example-Synchronize resources using Semaphore

Leave a Comment / By /
  • 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;
    }
 
    @Override
    public void run() {
        System.out.println("Initiate booking for "+ Thread.currentThread().getName());
        reservation.book(new 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 {
            semaphore.acquire();
            int duration = random.nextInt(100);
            System.out.printf("Time taken to book ticket for %s : %d\n",
                    Thread.currentThread().getName(), duration);
            sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

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

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

You may also like:

Create/Implement thread/ task using runnable interface & thread class (java/ example)

Create single thread pool using executor in java (with example)

Create custom thread pool in java without executor framework (example)

Create or simulate deadlock in multi threading (concurrency/ java/ example)

Java Concurrency – Thread join example with Runnable interface a

Concurrency – Producer & Consumer in java (Wait notify example)

Concurrency – Synchronize resources using ReentrantLock in java (example)