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 limited number of resources.

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

Sure! Here's a simple example:

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 of available resources. Here's an example:

import threading

semaphore = threading.Semaphore(2)  # allows 2 threads to access the resource

def thread_function():
    with semaphore:
        # critical section of code
        print('Semaphore acquired by', threading.current_thread().name)

This allows up to 2 threads to access 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, and use a semaphore when you want to limit access to a certain number of threads.