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">
 # Queues & Pipes 
 <div class="ans">
There are two ways that processes can communicate between themselves:

<ul>
<li>Queues</li>
<li>Pipes</li>
</ul>

## Queues
The multiprocessing module offers three types of queues which are all FIFO structures based on the <code class="abtc">queue</code> module's Queue (queue.Queue) implementation in the standard library. These 
are:

<ul>
<li>Simple Queue</li>

<li>Queue</li>

<li>Joinable Queue ( a subclass of Queue)</li>
</ul>


The queues in the multiprocessing module can be shared among multiple processes. Remember the following: 

<ul>
<li>We can enqueue any element in the queue that is picklable.</li>

<li>Queues are thread and process safe.</li>


<li>If multiple processes enqueue objects at the same time in a queue, the receiver may receive them out of order. However, all the object enqueued by a single process are always received in order.</li>

<li>The official documentation cautions that when an item is placed in an empty queue, there is a "infinitesimal" delay before the <code class="mthd">empty()</code> method returns false.</li>

</ul>
The last two bullet points if bothersome can be avoided by using a <code class="clazz">Queue</code> created by a <code class="clazz">Manager</code>, that we will discuss in the later sections.

Consider the program below. The main process acts as a producer and fills up a queue with ten messages. The child processes each access the queue and consumes messages from it.

### Using queues for interprocess communication


```python
def child_process(q):
 count = 0
 while not q.empty():
 print(q.get())
 count += 1

 print("child process {0} processed {1} items from the queue".format(current_process().name, count), flush=True)

if __name__ == '__main__':
 multiprocessing.set_start_method("forkserver")
 q = Queue()

 random.seed()
 for _ in range(100):
 q.put(random.randrange(10))

 p1 = Process(target=child_process, args=(q,))
 p2 = Process(target=child_process, args=(q,))

 p1.start()
 p2.start()

 p1.join()
 p2.join()

```



</div>
</div>

<div>
 # Queues & Pipes 
 <div>
There are two ways that processes can communicate between themselves:

<ul>
<li>Queues</li>
<li>Pipes</li>
</ul>

## Queues
The multiprocessing module offers three types of queues which are all FIFO structures based on the <code>queue</code> module's Queue (queue.Queue) implementation in the standard library. These 
are:

<ul>
<li>Simple Queue</li>

<li>Queue</li>

<li>Joinable Queue ( a subclass of Queue)</li>
</ul>


The queues in the multiprocessing module can be shared among multiple processes. Remember the following: 

<ul>
<li>We can enqueue any element in the queue that is picklable.</li>

<li>Queues are thread and process safe.</li>


<li>If multiple processes enqueue objects at the same time in a queue, the receiver may receive them out of order. However, all the object enqueued by a single process are always received in order.</li>

<li>The official documentation cautions that when an item is placed in an empty queue, there is a "infinitesimal" delay before the <code>empty()</code> method returns false.</li>

</ul>
The last two bullet points if bothersome can be avoided by using a <code>Queue</code> created by a <code>Manager</code>, that we will discuss in the later sections.

Consider the program below. The main process acts as a producer and fills up a queue with ten messages. The child processes each access the queue and consumes messages from it.

### Using queues for interprocess communication


```python
def child_process(q):
 count = 0
 while not q.empty():
 print(q.get())
 count += 1

 print("child process {0} processed {1} items from the queue".format(current_process().name, count), flush=True)

if __name__ == '__main__':
 multiprocessing.set_start_method("forkserver")
 q = Queue()

 random.seed()
 for _ in range(100):
 q.put(random.randrange(10))

 p1 = Process(target=child_process, args=(q,))
 p2 = Process(target=child_process, args=(q,))

 p1.start()
 p2.start()

 p1.join()
 p2.join()

```



</div>
</div>

This lesson discusses constructs that can be used for inter-process communication.

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

Queues & Pipes

Queues & Pipes

Queues