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">
   # Sync Manager   
   <div class="ans">

<p>So far we have been using <code class="mthd">time.sleep()</code> to delay the server manager from shutting down before other processes had a chance to retrieve shared objects from it. Obviously, this isn't a good strategy and we need a better way to coordinate among the different processes. Fortunately, there's a subclass of <code class="clazz">BaseManager</code> called the <code class="clazz">SyncManager</code> which offers proxies of synchronization constructs from the <code class="abtc">threading</code> module. Let's revisit the example we discussed under the manager section where we used a timer to delay shutting down the manager. We'll replace the base manager with a sync manager and create a semaphore proxy using the sync manager. The main process would wait on the semaphore while the child process after accessing the shared objects would set the semaphore. The code appears below:</p>

<p>SyncManager implements tools for synchronizing inter-process
communication in the style of threaded programming. </p>

## Using sync manager
<b>

```python
from multiprocessing.managers import SyncManager
from multiprocessing import Process
import time

# port number on which the manager runs and another can
# connect at
port_num = 55555


def process_task(sem):
    manager = SyncManager(address=('127.0.0.1', port_num))
    manager.register('get_my_string')
    manager.connect()
    proxy = manager.get_my_string()

    print(repr(proxy))
    print(str(proxy))
    print("child process exiting in 5 seconds")

    time.sleep(5)
    sem._callmethod('release')

    # invoking methods on the proxy's referent
    print(proxy._callmethod('isdigit'))
    print(proxy._callmethod('capitalize'))


if __name__ == '__main__':
    manager = SyncManager(address=('127.0.0.1', port_num))

    # Register our type
    my_string = "educative"
    manager.register('get_my_string', callable=lambda: my_string)
    manager.start()

    # get a proxy for a Semaphore
    sem = manager.Semaphore(0)

    # pass the semahore to the other process
    p = Process(target=process_task, args=(sem,))
    p.start()

    # wait for the semaphore to be set
    sem._callmethod('acquire')

    print("Main process exiting")

```
</b>

</div>
</div>


<div>
   # Sync Manager   
   <div>

<p>So far we have been using <code>time.sleep()</code> to delay the server manager from shutting down before other processes had a chance to retrieve shared objects from it. Obviously, this isn't a good strategy and we need a better way to coordinate among the different processes. Fortunately, there's a subclass of <code>BaseManager</code> called the <code>SyncManager</code> which offers proxies of synchronization constructs from the <code>threading</code> module. Let's revisit the example we discussed under the manager section where we used a timer to delay shutting down the manager. We'll replace the base manager with a sync manager and create a semaphore proxy using the sync manager. The main process would wait on the semaphore while the child process after accessing the shared objects would set the semaphore. The code appears below:</p>

<p>SyncManager implements tools for synchronizing inter-process
communication in the style of threaded programming. </p>

## Using sync manager
<b>

```python
from multiprocessing.managers import SyncManager
from multiprocessing import Process
import time

# port number on which the manager runs and another can
# connect at
port_num = 55555


def process_task(sem):
    manager = SyncManager(address=('127.0.0.1', port_num))
    manager.register('get_my_string')
    manager.connect()
    proxy = manager.get_my_string()

    print(repr(proxy))
    print(str(proxy))
    print("child process exiting in 5 seconds")

    time.sleep(5)
    sem._callmethod('release')

    # invoking methods on the proxy's referent
    print(proxy._callmethod('isdigit'))
    print(proxy._callmethod('capitalize'))


if __name__ == '__main__':
    manager = SyncManager(address=('127.0.0.1', port_num))

    # Register our type
    my_string = "educative"
    manager.register('get_my_string', callable=lambda: my_string)
    manager.start()

    # get a proxy for a Semaphore
    sem = manager.Semaphore(0)

    # pass the semahore to the other process
    p = Process(target=process_task, args=(sem,))
    p.start()

    # wait for the semaphore to be set
    sem._callmethod('acquire')

    print("Main process exiting")

```
</b>

</div>
</div>


This lesson discusses the SyncManager from the multiprocessing module which offers proxies for shared objects.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

SyncManager

Sync Manager