How is semaphore used in different programming languages?

How is semaphore used in different programming languages?

Semaphore is a synchronization mechanism used to control access to a common resource in concurrent programming. In languages like Java, semaphores are implemented using the Semaphore class from the java.util.concurrent package. In Python, you can use the Semaphore class from the threading module. Would you like examples in specific languages?

Yes, can you show me an example in Python?

Sure! Here's a simple example in Python:

import threading
import time

# Create a semaphore with 2 permits
semaphore = threading.Semaphore(2)

def worker(num):
    print(f'Worker {num} is waiting to enter.')
    semaphore.acquire()
    print(f'Worker {num} has entered.')
    time.sleep(2)  # Simulate work
    print(f'Worker {num} is leaving.')
    semaphore.release()

# Create and start multiple threads
for i in range(5):
    threading.Thread(target=worker, args=(i,)).start()

This code creates a semaphore that allows up to 2 threads to access the critical section at the same time.

What about in Java?

In Java, you can use the Semaphore class like this:

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private static final Semaphore semaphore = new Semaphore(2);

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            final int workerId = i;
            new Thread(() -> {
                try {
                    System.out.println("Worker " + workerId + " is waiting to enter.");
                    semaphore.acquire();
                    System.out.println("Worker " + workerId + " has entered.");
                    Thread.sleep(2000); // Simulate work
                    System.out.println("Worker " + workerId + " is leaving.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }).start();
        }
    }
}

This example allows up to 2 threads to enter the critical section at the same time.