Java Semaphore Vs Synchronized

Java Semaphore and synchronization are commonly used mechanisms for achieving thread synchronization in Java. While both aim to ensure shared resources' thread safety, they have different features and use cases. This article will explore the differences between Java Semaphore and synchronized, their advantages and disadvantages, and provide some example code to demonstrate their usage.

Java Semaphore

A Semaphore is a synchronization construct that provides a way to limit the number of threads that can access a shared resource simultaneously. It maintains a set of permits that threads can acquire and release. When a thread wants to access the shared resource, it must first acquire a permit from the Semaphore. If no permit is available, the thread will be blocked until one becomes available.

The Semaphore class in Java provides two main methods:

acquire()

This method tries to acquire a permit from the Semaphore. If no permit is available, the thread will be blocked until one becomes available.

release()

This method releases a permit back to the Semaphore.

Semaphore.java

import java.util.concurrent.Semaphore;
public class Semaphore{
  public static void main(String[] args) {
    Semaphore semaphore = new Semaphore(3); // Create a Semaphore with 3 permits
    for (int i = 1; i <= 5; i++) {
      new Thread(() -> {
        try {
          semaphore.acquire();
          System. out.println("Thread " + Thread.currentThread().getName() + " acquired a permit");
          Thread.sleep(2000); // Simulate some work
        } catch (InterruptedException e) {
          e.printStackTrace();
        } finally {
          semaphore.release();
          System. out.println("Thread " + Thread.currentThread().getName() + " released a permit");
        }
      }).start();
    }
  }
}

Output:

Thread Thread-2 acquired a permit
Thread Thread-1 acquired a permit
Thread Thread-0 acquired a permit
Thread Thread-3 acquired a permit
Thread Thread-4 acquired a permit
Thread Thread-1 released a permit
Thread Thread-2 released a permit
Thread Thread-0 released a permit
Thread Thread-4 released a permit
Thread Thread-3 released a permit

In this example, we create a Semaphore with three permits. We then create five threads, each trying to acquire a permit from the Semaphore. Since only three permits are available, only three threads can acquire a permit at a time. The other two threads will be blocked until a permit becomes available. Once a thread acquires a permit, it sleeps for 2 seconds to simulate some work and then releases the permit back to the Semaphore.

Synchronized

Synchronized is a keyword in Java that can be used to create synchronized blocks and methods. When a method or block is marked as synchronized, only one thread can execute it simultaneously. Other threads that try to execute the same synchronized block or method will be blocked until the previous thread finishes.

Here is an example code demonstrating the usage of synchronized in Java:

public class Main {
  private int count = 0;
  public synchronized void increment() {
    count++;
  }
  public static void main(String[] args) {
    Main synchronizedExample = new Main();
    for (int i = 1; i <= 5; i++) {
      new Thread(() -> {
        for (int j = 1; j <= 1000; j++) {
          synchronizedExample.increment();
        }
      }).start();
    }
    try {
      Thread.sleep(5000); // Wait for all threads to finish
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("Count: " + synchronizedExample.count);
  }
}

Output

Count: 5000

In this example, we create a class called SynchronizedExample with a synchronized method called increment(). This method increments a shared variable called count. We then create five threads, each of which calls the increment() method 1000 times. Since the increment() method is synchronized, only one thread can execute simultaneously. This ensures that the count variable is incremented in a thread-safe manner. Finally, we wait for all threads to finish and print the final value of the count.

Differences Between Java Semaphore and Synchronized

Advantages and disadvantages of Java Semaphore and synchronized

• Java Semaphore is more flexible than synchronized and provides a way to limit the number of threads that can access a shared resource simultaneously. However, Semaphore is more complex to use and can be more difficult to understand. It is also easier to introduce bugs with Semaphore since it requires manual permit management.
• On the other hand, synchronized is simpler to use and provides a way to ensure thread safety without needing to manage permits. However, it is less flexible than Semaphore and can lead to contention between threads if used improperly.
• Semaphore can be more efficient than synchronized in certain scenarios because it allows for finer-grained control over thread access to shared resources. For example, suppose there are multiple resources that threads need to access. In that case, a Semaphore can limit the number of threads accessing each resource simultaneously, thereby reducing contention and improving performance. In contrast, using synchronized to protect access to multiple resources would require locking and unlocking a single lock, potentially leading to contention and reduced performance.
• Another advantage of Semaphores over synchronized ones is that semaphores can be used to implement more complex synchronization patterns. For example, Semaphore can implement a barrier, a synchronization pattern where multiple threads wait until all threads have reached a certain point in their execution before continuing. This can be useful in parallel programming, where multiple threads must complete a computation before combining results. In contrast, synchronized cannot be used to implement a barrier directly.
• Semaphore also provides a way to deal with timeouts when acquiring permits, which can be useful when a thread needs to access a shared resource but cannot wait indefinitely for a permit to become available. For example, suppose a thread needs to access a network resource, and the network is down. In that case, the thread can wait a limited amount of time for the network to become available, after which it can exit gracefully instead of indefinitely.
• However, Semaphore does have some drawbacks compared to synchronized ones. One potential issue with Semaphores is that they can be more difficult to use correctly than synchronized, especially when dealing with complex synchronization patterns. It can also be more difficult to debug issues related to Semaphore since more moving parts are involved in managing permits.
• Another potential issue with Semaphore is that it can be more prone to deadlocks than synchronized. This can occur when multiple threads wait for permits to become available, but the order in which the threads are granted permits leads to a situation where only some threads can progress. In contrast, synchronized is less prone to deadlocks because it locks the entire shared resource, ensuring that only one thread can access it at a time.
• The choice between Semaphore and synchronized depends on the application's specific use case and requirements. Semaphore is more appropriate for cases where there is a need to limit the number of threads accessing a shared resource. At the same time, synchronization is more appropriate for cases where mutual exclusion is needed.

Conclusion

In this article, we have explored the differences between Java Semaphore and synchronized, their advantages and disadvantages, and provided some example code to demonstrate their usage. Semaphore and synchronization are important mechanisms for achieving thread synchronization in Java, and the choice between the two depends on the application's specific use case and requirements. Semaphore is more flexible and efficient than synchronized in certain scenarios, but it can also be more difficult to use and more prone to deadlocks. Synchronized is simpler to use but could be more flexible and can lead to contention between threads if used properly. Developers can write thread-safe and efficient Java programs by understanding each mechanism's differences and appropriate use cases.