Java Semaphore

In Java, we use semaphore in the thread synchronization. It is used to control access to a shared resource that uses a counter variable. Java also provides a Semaphore class that contains constructors and various methods to control access over the shared resource. We will discuss it later in this section.

Before moving ahead in this section, first, we will understand what is semaphore, types of semaphore, how it works, and how to implement semaphore. After knowing all about it, we will move to the Java semaphore programs.

What is a semaphore?

A Semaphore is used to limit the number of threads that want to access a shared resource. In other words, it is a non-negative variable that is shared among the threads known as a counter. It sets the limit of the threads. A mechanism in which a thread is waiting on a semaphore can be signaled by other threads.

If counter > 0, access to shared resources is provided.
If counter = 0, access to shared resources is denied.

In short, the counter keeps tracking the number of permissions it has given to a shared resource. Therefore, semaphore grants permission to threads to share a resource.

Characteristics of Semaphore

There are the following characteristics of a semaphore:

It provides synchronization among the threads.
It decreases the level of synchronization. Hence, provides a low-level synchronization mechanism.
The semaphore does not contain a negative value. It holds a value that may either greater than zero or equal to zero.
We can implement semaphore using the test operation and interrupts, and we use the file descriptors for executing it.

Working of Semaphore

Semaphore controls over the shared resource through a counter variable. The counter is a non-negative value. It contains a value either greater than 0 or equal to 0.

If counter > 0, the thread gets permission to access the shared resource and the counter value is decremented by 1.
Else, the thread will be blocked until a permit can be acquired.
When the execution of the thread is completed then there is no need for the resource and the thread releases it. After releasing the resource, the counter value incremented by 1.
If another thread is waiting for acquiring a resource, the thread will acquire a permit at that time.
If counter = 0, the thread does not get permission to access the shared resource.

Let's understand the working of semaphore with the help of a flow chart.

Types of Semaphores

There are four types of semaphores, which are as follows:

Counting Semaphores
Bounded Semaphores
Timed Semaphores
Binary Semaphores

Let's discuss one by one in detail.

Counting Semaphores

The counting semaphores are used to resolve the situation in which more than one process wants to execute in the critical section, simultaneously. Hence to overcome this problem we use counting semaphore. For example, consider the following code snippet.

Let's see the implementation of the counting semaphores.

CountingSemaphoresExample.java

public class CountingSemaphoreExample 
{
private int signal = 0;
public synchronized void take() 
{
this.signal++;
this.notify();
}
public synchronized void release() throws InterruptedException
{
while(this.signal == 0) 
wait();
this.signal--;
}
}

Bounded Semaphores

We can set the upper bound limit using the bounded semaphores. It is used in place of the counting semaphores because the counting semaphores do not contain any upper bound value. The upper bound value denotes how many signals it can store. For example, consider the following code snippet.

Let's see the implementation of the bounded semaphore.

BoundedSemaphoresExample.java

public class BoundedSemaphoresExample
{
private int signals = 0;
private int bound = 0;
public BoundedSemaphoreexample(int upperBound)
{
this.bound = upperBound;
}
public void synchronized take() throws InterruptedException
{
while(this.signals == bound)
wait();
this.signals++;
this.notify++;
}
public void synchronized release() throws InterruptedException
{
while(this.signal == 0)
wait();
this.signals--;
}
}

Timed Semaphores

The timed semaphores allow a thread to run for a specified period of time. After a particular time, the timer resets and releases all other permits.

Let's see the implementation of the timed semaphores.

TimedSemaphoresExample.java

class TimedSemaphoresExample 
{
private TimedSemaphore semaphore;
TimedSemaphoreExample(long period, int slotLimit) 
{
semaphore = new TimedSemaphore(period, TimeUnit.SECONDS, slotLimit);
}
boolean tryAdd() 
{
return semaphore.tryAcquire();
}
int availableSlots() 
{
return semaphore.getAvailablePermits();
}
}

Binary Semaphores

The binary semaphores are the same as counting semaphores. But remember that it accepts only binary values either 0 or 1. Its implementation is easy in comparison to other semaphores. If the value is 1, the signal operation is success, fails otherwise.

Let's see the implementation of binary semaphores.

BinarySemaphoresExample.java

public class BinarySemaphoreExample 
{
private boolean locked = false;
BinarySemaphore(int initial) 
{
locked = (initial == 0);
}
public synchronized void waitForNotify() throws InterruptedException 
{
while (locked) 
{
wait();
}
locked = true;
}
public synchronized void notifyToWakeup() 
{
if (locked) 
{
notify();
}
locked = false;
}
}

Semaphore in Java

In Java, it is a thread synchronization construct. The construct uses a variable known as a counter that controls access over the shared resource. It is a type of variable which is used to manage concurrent processes and also synchronize them. It is also used to avoid race conditions. It restricts the number of threads to access a shared resource.

For example, we can restrict a file to access up to 10 connections simultaneously.

Java Semaphore Class

Java provides a Semaphore class to implement the semaphore mechanism. It belongs to the java.util.concurrent package. It implements the Serializable interface. Hence, manual implementation is not required.

The Semaphore class provides the following two constructors:

Semaphore(int permits)
Semaphore(int permits, boolean fair)

Semaphore(int permits)

It creates a Semaphore and parses the number of permits (initial number of permits available) as an argument. It specifies the number of threads that can share a resource at a time. The value of permits may be negative. In such a case, a release must occur before any acquires will be granted.

Syntax:

Semaphore(int permits, boolean fair)

It creates a Semaphore with the given number of permits and the given fairness settings.

Syntax:

It parses two parameters:

permits: The value of permits may be negative. In such a case, the release must occur before any acquires will be granted.
fair: If we set the value to true, the semaphore guarantees FIFO to the threads in the order they are requested, false By default, all the threads that are waiting for the resource grants permit in an undefined order.

Methods of the Semaphore Class

The class provides the following methods:

acquire() Method: The method acquire the permits from the semaphore, blocking until one is available, or the thread is interrupted. It reduces the number of available permits by 1.

If there is no permit is available for the current thread, the thread becomes disabled for the thread scheduling purposes. The current thread goes in the inactive state until one of two things happens:

If the other thread invokes the release() method to release the resource then the current thread gets permits.
If the other thread interrupts the current thread.

It throws InterruptedException if the current thread is interrupted. The method does not return any value.

Syntax:

release() Method: It releases a permit and returns it to the semaphore. It increments the number of available permits by 1. If a thread tries to acquire a permit, the semaphore grants permission to acquire the resource that was just released by other threads. Further, that thread is considered for thread scheduling purposes.

Syntax:

availablePermits() Method: The method returns the number of permits available in semaphore for granting the resource. Usually, it is used for debugging and testing purposes.

Syntax:

Let's understand the above methods through a simple example.

Semaphore semaphore = new Semaphore(6);  //creates a semaphore with 6 permits
semaphore.acquire();   //acquire 1 ticket
semaphore.availablePermits();  //current available permits is 5
semaphore.release();  //releases the acquire ticket and increments the permit by 1
semaphore.availablePermits();  //current available permits is 5

Using Semaphore as Lock

Java allows us to use a semaphore as a lock. It means, it locks the access to the resource. Any thread that wants to access the locked resource, must call the acquire() method before accessing the resource to acquire the lock. The thread must release the lock by calling the release() method, after the completion of the task. Remember that set the upper bound to 1. For example, consider the following code snippet:

Semaphore sem= new Semaphore(1);
...
sem.acquire();
try
{
//critical section
} 
finally 
{
sem.release();
}

Let's see an example of a semaphore and use semaphore as a lock.

SemaphoreAsLock.java

import java.util.concurrent.*; 
//a shared resource or class. 
class Shared 
{ 
static int count = 0; 
} 
class DemoThread extends Thread 
{ 
//object of the Semaphore class
Semaphore semaphore; 
//variable for storing the thread name
String threadName; 
public DemoThread(Semaphore semaphore, String threadName) 
{ 
super(threadName); 
this.semaphore = semaphore; 
this.threadName = threadName; 
} 
@Override
public void run() 
{ 
// run by thread A 
if(this.getName().equals("A")) 
{ 
System.out.println("Starting thread " + threadName); 
try
{ 
// First, get a permit. 
System.out.println(threadName + " is waiting for a permit."); 
//acquiring the lock 
semaphore.acquire(); 
System.out.println(threadName + " gets a permit.");
//current thread A is accessing the resource and the 
//other threads are waiting for to get the resource 
//until the thread A release the lock 
for(int i=0; i < 5; i++) 
{ 
//thread A has acquired the resource 
//hence the value of the count is incremented to 1	
Shared.count++; 
System.out.println(threadName + ": " + Shared.count); 
//now, allowing a context switch for thread B to execute 
//sleeps thread for 1 second
Thread.sleep(1000); 
} 
} 
catch (InterruptedException e) 
{ 
e.printStackTrace(); 
} 
//release the permit
System.out.println("Thread " +threadName + " releases the permit."); 
semaphore.release(); 
} 
// run by thread B 
else
{ 
System.out.println("Starting thread " + threadName); 
try
{ 
//first, get a permit
System.out.println("Thread " +threadName + " is waiting for a permit."); 
//acquiring the lock 
semaphore.acquire(); 
System.out.println("Thread " +threadName + " gets a permit."); 
//Now, accessing the shared resource. 
//other waiting threads will wait, until this 
//thread release the lock 
for(int i=0; i < 5; i++) 
{ 
//decrements the count value	
Shared.count--; 
System.out.println(threadName + ": " + Shared.count); 
//Now, allowing a context switch -- if possible. 
//for thread A to execute 
//sleeps thread for 1 second
Thread.sleep(1000); 
} 
} 
catch (InterruptedException e) 
{ 
e.printStackTrace(); 
} 
//release the permit 
System.out.println("Thread " +threadName + " releases the permit."); 
//release the resource
semaphore.release(); 
} 
} 
} 
//creating driver class
public class SemaphoreAsLock 
{ 
public static void main(String args[]) throws InterruptedException 
{ 
//creating the constructor of the Semaphore with initial permit 1 
Semaphore semaphore = new Semaphore(1); 
//creating two threads with the name A and B 
//thread A increments the count value 
//while the thread B decrements the count value
DemoThread dt1 = new DemoThread(semaphore, "A"); 
DemoThread dt2 = new DemoThread(semaphore, "B"); 
//stating both threads A and B 
dt1.start(); 
dt2.start(); 
//waiting for thread A 
dt1.join(); 
//waiting for thread B
dt2.join(); 
//after completing the execution of the threads, the count value will be 0 always
System.out.println("count: " + Shared.count); 
} 
}

Output:

Note: When we execute the above program, we get different output every time. So, your output may differ from the output shown above.

Java Semaphore Example

Let's understand the semaphore mechanism through a Java program. In the following example, we have created a constructor of the Semaphore class with the initial permit value 3.

SemaphoreExample.java

import java.util.concurrent.Semaphore;
public class SemaphoreExample 
{
//creating constructor of the Semaphore with the initial value 3
static Semaphore semaphore = new Semaphore(3);
static class DemoThread extends Thread 
{
String name = "";
//constructor of the DemoThread class
DemoThread(String name) 
{
this.name = name;
}
public void run() 
{
try 
{
System.out.println("Thread "+name + " : acquiring lock...");
System.out.println("Thread "+name + " : available Semaphore permits is: "+ semaphore.availablePermits());
//thread A acquire lock and the permit count decremented by 1
semaphore.acquire();
System.out.println("Thread "+name + " : got the permit!");
try 
{
for (int i = 1; i <= 5; i++) 
{
System.out.println("Thread "+name + " : is performing operation " + i+ ", available Semaphore permits : "+ semaphore.availablePermits());
//sleep 2 second
Thread.sleep(2000);
}
} 
finally 
{
System.out.println("Thread "+name + " : releasing lock...");
//invoking release() method after successful execution
semaphore.release();
//prints the total number of available permits
System.out.println("Thread "+name + " : available Semaphore permits is: "+ semaphore.availablePermits());
}
} 
catch (InterruptedException e) 
{
e.printStackTrace();
}
}
}
//main method
public static void main(String[] args) 
{
//prints the total number of available permits
System.out.println("Total available Semaphore permits is: "+ semaphore.availablePermits());
//creating four threads namely A, B, C, and D
DemoThread t1 = new DemoThread("A");
//staring thread A
t1.start();
DemoThread t2 = new DemoThread("B");
//staring thread B
t2.start();
DemoThread t3 = new DemoThread("C");
//staring thread C
t3.start();
DemoThread t4 = new DemoThread("D");
//staring thread D
t4.start();
}
}

Output: