What are the differences between locks and semaphores in Python?

What are the differences between locks and semaphores in Python?

Locks and semaphores are both synchronization primitives in Python, but they serve different purposes. A lock allows only one thread to access a resource at a time, while a semaphore can allow multiple threads to access a resource, up to a specified limit.

Can you give me an example of how to use a lock?

Sure! Here's a simple example using a lock in Python:

import threading

lock = threading.Lock()

def thread_function():
    with lock:
        # Critical section of code
        print('Lock acquired by', threading.current_thread().name)

This ensures that only one thread can execute the critical section at a time.

What about semaphores? How do they work?

Semaphores maintain a count that allows a certain number of threads to access a resource. Here's an example:

import threading

semaphore = threading.Semaphore(2)  # Allow up to 2 threads

def thread_function():
    with semaphore:
        print('Semaphore acquired by', threading.current_thread().name)

In this case, up to two threads can enter the critical section simultaneously.

When should I use a lock instead of a semaphore?

Use a lock when you need exclusive access to a resource, ensuring that only one thread can access it at a time. Use a semaphore when you want to limit access to a resource to a specific number of threads.