What is Semaphore in Java and its Use?

What is Semaphore in Java?

Semaphore in Java is a variable that is used to manage processes that run in parallel. It is a non-negative variable that indicates the number of resources in the system that are available at a point in time. By using counters, the semaphore controls the shared resources to ensure that threads running simultaneously are able to access the resources and avoid race conditions. Thus the semaphore protects critical sections by using synchronized constructs. 

What Are the Types of Semaphore?

There are two types of Semaphore:

1. Counting Semaphore

The semaphore variable is initialized with the number of resources available. When a process needs to acquire a shared resource, wait() function is invoked and the value of the semaphore is reduced by 1. Once the process is done using the resource, it is released by invoking the signal() function. The value of the variable is increased by 1. When the semaphore value is 0, none of the resources are available and the process has to wait till a resource is released.

2. Binary Semaphore

In a binary semaphore, the value of the variable will be either 0 or 1. The value is set to 1 in the beginning and if a process wants to use a shared resource, it can invoke the wait() function, and the value changes from 1 to 0. Once the process is done using the resource, it is released by invoking the signal() function. The value of the variable changes from 0 to 1. When the value of the semaphore is 0 and a process has to wait to acquire the shared resource which has to be released by the previous process. 

How Does a Semaphore Work?

The counter of the semaphore holds a value of 0 or higher. 

• When the value of the counter is greater than 0, the thread is allowed to access the shared resource and the counter value reduces by 1.
• Otherwise until a permit can be obtained, the thread is blocked.
• After the thread completes execution, it releases the resource that is no longer required. Once the resource is released, the counter value is increased by 1.
• Another thread awaiting the acquisition of the same resource can now obtain a permit to access the resource. 
• If the counter is 0, permission to access the resource is denied

The below flowchart indicates the working of Semaphore:

Timed Semaphore

As the name indicates, a timed semaphore permits a thread to run for a specific amount of time. Once the time elapses, all permissions are released and the timer is reset. 

Semaphore vs. Mutex

Implementation of Semaphore 

import java.util.concurrent.*;

//Will take Resource as shared class

class Resource

{

    static int count = 0;

} 

class MyDemo extends Demo

{

    Semaphore sem;

    String threadName;

    public MyDemo(Semaphore sem, String threadName)

    {

        super(threadName);

        this.sem = sem;

        this.threadName = threadName;

    }

    @Override

    public void run() {   

        // Run By X

        if(this.getName().equals("X"))

        {

            System.out.println("Starting " + threadName);

            try

            {

                // Will get the permit to access shared resource

                System.out.println(threadName + " awaiting permit.");           

                // acquiring the lock

                sem.acquire();            

                System.out.println(threadName + " received a permit.");        

                // Now, accessing the shared resource and rest will wait 

                for(int i=0; i < 7; i++)

                {

                    Resource.count++;

                    System.out.println(threadName + ": " + Resouce.count);    

                    // Now thread Y will try  to execute

                    Thread.sleep(20);

                }

            } catch (InterruptedException exc) {

                    System.out.println(exc);

                }

                // Release the permit.

                System.out.println(threadName + " released permit.");

                sem.release();

        }         

        // run by thread Y

        else

        {

            System.out.println("Starting " + threadName);

            try

            {

                // First, Y will try to get permit

                System.out.println(threadName + " awaiting permit.");             

                // acquiring the lock

                sem.acquire();            

                System.out.println(threadName + " received a permit.");       

                // Now, accessing the shared resource and others will wait                 

                for(int i=0; i < 7; i++)

                {

                    Resource.count--;

                    System.out.println(threadName + ": " + Resource.count);         

                    // Now, allowing a context switch -- if possible.

                    // for thread X to execute

                    Thread.sleep(20);

                }

            } catch (InterruptedException exc) {

                    System.out.println(exc);

                }

                // Release the permit.

                System.out.println(threadName + " released permit.");

                sem.release();

        }

    }

}

public class SemTest

{

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

    {

        // creating a Semaphore object

        // with number of permits 1

        Semaphore sem = new Semaphore(1);         

        // creating two threads with name X and Y

        // Here thread X will increment and Y will decrement the counter

        MyDemo md1 = new MyDemo(sem, "X");

        MyDemo md2 = new MyDemo(sem, "Y");         

        // stating threads X and Y

        md1.start();

        md2.start();        

        // waiting for threads X and Y

        md1.join();

        mtd.join();    

        System.out.println("count: " + Resource.count);

    }

}

Output

Starting X

Starting Y

X awaiting permit

Y awaiting permit

X:1

X:2

X:3

X:4

X:5

X:6

X:7

X released permit

Y received a permit

Y:6

Y:5

Y:4

Y:3

Y:2

Y:1

Y:0

Y released permit

count:0

FAQs

1. What is the use of semaphore?

Semaphore is used to achieve process synchronization in Java. It uses a non-negative counter variable to provide access to the shared resource at a given time by a thread. The counter tracks the number of permissions provided to threads. 

2.What are two types of semaphore?

The two types of semaphore are

1. Binary Semaphore: A semaphore with the value of 0 or 1 to manage parallel processes in sync and execute mutual exclusion. The value 1 indicates success and 0 indicates failure 
2. Counting Semaphore: A semaphore that holds a value indicating the maximum number of processes that can enter the critical section simultaneously.  

3. Is a semaphore a queue?

A queue is an ordered linear data structure that follows the First in First Out (FIFO) principle. However, a semaphore does not ensure a specific order and is not a queue.  

4. What is semaphore and mutex in Java?

Mutex is a mutually exclusive object that controls access to a resource. It uses a locking mechanism to ensure that only one thread accesses the resource at a given time by entering the critical section. Once the thread exits the section, the resource is released by it. It is used to achieve process synchronization. 

Semaphore is also used for realizing process synchronization, however, it uses the signaling mechanism. By deploying a non-negative counter variable it shares signals between threads that need access to the same resource.

Conclusion

In this article we discussed Semaphore in Java and what are its uses. If you are looking to upskill further, then we highly recommend you to take up the Simplilearn’s Post Graduate Program in Full Stack Web Development. This course can help you hone the key Java skills and make you job ready with HIRIST and HackerEarth. Complete the course and get a guaranteed job with an average pay of 6.7 LPA.

If you have any doubts or queries regarding the article or the course, feel free to post them in the comments below. Our team will get back to you at the earliest.