The ultimate guide to senior engineering interviews. Strategies developed by FAANG engineers on Python concurrency, multithreading, monitors, and event loops. Prep faster for top company questions.

Concurrency in Python is one of the most complex and advanced topics brought up during senior engineering interviews. Knowledge of concurrency and multithreading can put interviewees at a considerable advantage. This course lays the foundations of advanced concurrency and multithreading and explains concepts such as Monitors, Event Loops and Deferred Callbacks in depth. It also builds simple and complete solutions to popular concurrency problems that can be asked about in interviews like the Reader-Writer Problem and the Dining Philosopher Problem. While prior knowledge of concurrency is not required to follow through with this course, familiarity with the very basic Python would be helpful.

Python Concurrency for Senior Engineering Interviews

<div class="card">
   # Lock   
   <div class="ans">
<p>Lock is the most basic or primitive synchronization construct available in Python. It offers two methods: <code class="mthd">acquire()</code> and <code class="mthd">release()</code>. A Lock object can only be in two states: <b>locked</b> or <b>unlocked</b>. <span class="hi-yl">A   Lock object can only be unlocked by a thread that locked it in the first place.</span></p>

<p>A <code class="clazz">Lock</code> object is equivalent of a mutex that you read about in operating systems theory.</p>

## Acquire
<p>Whenever a Lock object is created it is initialized with the unlocked state. Any thread can invoke <code class="mthd">acquire()</code> on the lock object to lock it. Advanced readers should note that <code class="mthd">acquire()</code> can only be invoked by a single thread at any point because the GIL ensures that only one thread is being executed by the interpreter. This is in contrast to other programming languages with more robust threading models where multiple threads could be executing on different cores and theoretically attempt to acquire a lock at exactly the same time.</p>

<p>If a <code class="clazz">Lock</code> object is already acquired/locked and a thread attempts to <code class="mthd">acquire()</code> it, the thread will be blocked till the <code class="clazz">Lock</code> object is released. If the caller doesn't want to be blocked indefinitely, a floating point timeout value can be passed in to the <code class="mthd">acquire()</code> method. The method returns true if the lock is successfully acquired and false if not.</p>

## Release
<p>The <code class="mthd">release()</code> method will change the state of the Lock object to unlocked and give a chance to other waiting threads to acquire the lock. If multiple threads are already blocked on the acquire call then only one arbitrarily chosen (varies across implementations) thread is allowed to acquire the Lock object and proceed.</p>

## Example
<p>An example is presented below where two threads share a list and one of the threads tries to modify the list while the other attempts to read it. Using a lock object we make sure that the two threads share the list in a thread-safe manner.</p>

```python
sharedState = [1, 2, 3]
my_lock = Lock()


def thread1_operations():
    my_lock.acquire()
    print("{0} has acquired the lock".format(current_thread().getName()))

    time.sleep(3)  
    sharedState[0] = 777

    print("{0} about to release the lock".format(current_thread().getName()))
    my_lock.release()
    print("{0} released the lock".format(current_thread().getName()))


def thread2_operations():
    print("{0} is attempting to acquire the lock".format(current_thread().getName()))
    my_lock.acquire()
    print("{0} has acquired the lock".format(current_thread().getName()))

    print(sharedState[0])
    print("{0} about to release the lock".format(current_thread().getName()))
    my_lock.release()
    print("{0} released the lock".format(current_thread().getName()))

if __name__ == "__main__":
    # create and run the two threads
    thread1 = Thread(target=thread1_operations, name="thread1")
    thread1.start()

    thread2 = Thread(target=thread2_operations, name="thread2")
    thread2.start()

    # wait for the two threads to complete
    thread1.join()
    thread2.join()
```
</b>

</div>
</div>


<div>
   # Lock   
   <div>
<p>Lock is the most basic or primitive synchronization construct available in Python. It offers two methods: <code>acquire()</code> and <code>release()</code>. A Lock object can only be in two states: <b>locked</b> or <b>unlocked</b>. <span>A   Lock object can only be unlocked by a thread that locked it in the first place.</span></p>

<p>A <code>Lock</code> object is equivalent of a mutex that you read about in operating systems theory.</p>

## Acquire
<p>Whenever a Lock object is created it is initialized with the unlocked state. Any thread can invoke <code>acquire()</code> on the lock object to lock it. Advanced readers should note that <code>acquire()</code> can only be invoked by a single thread at any point because the GIL ensures that only one thread is being executed by the interpreter. This is in contrast to other programming languages with more robust threading models where multiple threads could be executing on different cores and theoretically attempt to acquire a lock at exactly the same time.</p>

<p>If a <code>Lock</code> object is already acquired/locked and a thread attempts to <code>acquire()</code> it, the thread will be blocked till the <code>Lock</code> object is released. If the caller doesn't want to be blocked indefinitely, a floating point timeout value can be passed in to the <code>acquire()</code> method. The method returns true if the lock is successfully acquired and false if not.</p>

## Release
<p>The <code>release()</code> method will change the state of the Lock object to unlocked and give a chance to other waiting threads to acquire the lock. If multiple threads are already blocked on the acquire call then only one arbitrarily chosen (varies across implementations) thread is allowed to acquire the Lock object and proceed.</p>

## Example
<p>An example is presented below where two threads share a list and one of the threads tries to modify the list while the other attempts to read it. Using a lock object we make sure that the two threads share the list in a thread-safe manner.</p>

```python
sharedState = [1, 2, 3]
my_lock = Lock()


def thread1_operations():
    my_lock.acquire()
    print("{0} has acquired the lock".format(current_thread().getName()))

    time.sleep(3)  
    sharedState[0] = 777

    print("{0} about to release the lock".format(current_thread().getName()))
    my_lock.release()
    print("{0} released the lock".format(current_thread().getName()))


def thread2_operations():
    print("{0} is attempting to acquire the lock".format(current_thread().getName()))
    my_lock.acquire()
    print("{0} has acquired the lock".format(current_thread().getName()))

    print(sharedState[0])
    print("{0} about to release the lock".format(current_thread().getName()))
    my_lock.release()
    print("{0} released the lock".format(current_thread().getName()))

if __name__ == "__main__":
    # create and run the two threads
    thread1 = Thread(target=thread1_operations, name="thread1")
    thread1.start()

    thread2 = Thread(target=thread2_operations, name="thread2")
    thread2.start()

    # wait for the two threads to complete
    thread1.join()
    thread2.join()
```
</b>

</div>
</div>


Python's Lock is the equivalent of a Mutex and this lesson looks at its various uses.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Lock

Lock

Acquire