How do I use semaphores for thread safety?

What are semaphores and how do they help with thread safety?

Semaphores are synchronization primitives that control access to shared resources by multiple threads, ensuring thread safety.

Can you give me an example of how to implement a semaphore in Python?

Sure! You can use the threading module in Python. Here's a simple example:

import threading

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

def access_resource(thread_id):
    print(f'Thread {thread_id} is trying to access the resource.')
    with semaphore:
        print(f'Thread {thread_id} has accessed the resource.')
        # Simulate resource access
        time.sleep(1)
    print(f'Thread {thread_id} has released the resource.')

# Create multiple threads
threads = [threading.Thread(target=access_resource, args=(i,)) for i in range(5)]

# Start the threads
for thread in threads:
    thread.start()

# Wait for all threads to complete
for thread in threads:
    thread.join()

What happens if a thread tries to access the resource when the semaphore is at its limit?

If a thread tries to access the resource when the semaphore's limit is reached, it will block and wait until another thread releases the semaphore.