Concurrent Resource Access with Semaphores

Semaphores are fundamental synchronization primitives in concurrent programming, used to control access to shared resources and prevent race conditions. This challenge asks you to implement a semaphore class in Python, allowing multiple threads or processes to safely access a limited number of resources. Understanding and implementing semaphores is crucial for building robust and efficient concurrent applications.

Problem Description

You are tasked with creating a Semaphore class in Python. This class should manage a limited number of available resources. Threads or processes attempting to access a resource must acquire a permit from the semaphore. Once the resource is no longer needed, the permit must be released back to the semaphore. The semaphore should prevent more than the specified number of resources from being accessed concurrently.

Key Requirements:

• Initialization: The Semaphore class should be initialized with an integer value, representing the initial number of available resources.
• acquire() method: This method should block until a resource becomes available (i.e., the semaphore's internal counter is greater than 0). Upon acquiring a resource, the counter should be decremented.
• release() method: This method should increment the semaphore's internal counter, potentially unblocking a thread/process waiting in the acquire() method.
• Thread Safety: The acquire() and release() methods must be thread-safe, meaning they should function correctly even when called concurrently from multiple threads. Use appropriate locking mechanisms to ensure atomicity.

Expected Behavior:

• If value is positive, the semaphore behaves like a counter, allowing up to value threads/processes to access the resource concurrently.
• If value is zero, threads/processes calling acquire() will block until another thread/process calls release().
• If value is negative, it represents an error condition (though this challenge doesn't require explicit error handling beyond the basic functionality).

Edge Cases to Consider:

• Multiple threads/processes attempting to acquire the semaphore simultaneously.
• Releasing a semaphore more times than it was acquired. (While not strictly required to handle, consider how it might affect the internal state).
• Initialization with a negative value (should not cause immediate errors, but behavior should be consistent).

Examples

Example 1:

Input: semaphore = Semaphore(2); thread1 acquires, thread2 acquires, thread3 tries to acquire
Output: thread1 and thread2 proceed, thread3 blocks
Explanation: The semaphore allows 2 concurrent accesses. Thread 3 must wait.

Example 2:

Input: semaphore = Semaphore(1); thread1 acquires, thread1 releases, thread2 acquires
Output: thread2 proceeds
Explanation: The semaphore allows only 1 concurrent access. After thread1 releases, thread2 can acquire.

Example 3: (Edge Case)

Input: semaphore = Semaphore(0); thread1 acquires, thread2 acquires, thread1 releases
Output: thread2 proceeds, then thread3 proceeds (if thread3 was waiting)
Explanation:  The semaphore starts with 0 resources.  Thread1 blocks. When thread1 releases, thread2 proceeds.

Constraints

• The semaphore class must be implemented using Python's built-in threading module for thread safety.
• The acquire() method should block indefinitely if no resources are available.
• The release() method should not raise an error if the semaphore is already at its maximum value.
• The internal counter of the semaphore should always be a non-negative integer.

Notes

• Consider using a threading.Lock to protect the semaphore's internal counter and ensure thread safety.
• The acquire() method can use threading.Condition to efficiently manage waiting threads. This allows threads to sleep until the semaphore's state changes.
• Focus on the core functionality of acquiring and releasing resources. Error handling beyond basic functionality is not required for this challenge.
• Think about how to avoid busy-waiting in the acquire() method.