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="ans">
# Using a Background Thread

<p>The previous solution consisted of manipulating pointers in time, thus avoiding threads altogether. Another solution is to use threads to solve the token bucket filter problem. We instantiate one thread to add a token to the bucket after every one second. The user thread invokes the <code class="mthd">getToken()</code> method and is granted one if available. We instantiate one thread to add a token to the bucket after every one second. The user thread invokes the <code class="mthd">getToken()</code> method and is granted one if available. </p>

<p>One simplification as a result of using threads is we now only need to remember the current number of tokens held by the token bucket filter object. We'll add an additional method <code class="mthd">daemonThread()</code> that will be executed by the thread that adds a token every second to the bucket. The skeleton of our class looks as follows:</p>

```python
class MultithreadedTokenBucketFilter(TokenBucketFilter):
    def __init__(self, maxTokens):
        self.MAX_TOKENS = int(maxTokens)
        self.possibleTokens  = int(0)
        self.ONE_SECOND = int(1)
        self.cond = Condition()

    def daemonThread(self):

    def getToken(self):

```
<br/>
<p>The logic of the daemon thread is simple. It sleeps for one second, wakes up, checks if the number of tokens in the bucket is less than the maximum allowed tokens, if yes increments the <code class="mthd">possibleTokens</code> variable and if not goes back to sleep for a second again.</p>

<p>The implementation of the <code class="mthd">getToken()</code> is even simpler. The user thread checks if the number of tokens is greater than zero, if yes it simulates taking away a token by decrementing the variable <code class="mthd">possibleTokens</code>.  If the number of available tokens is zero then the user thread must wait and be notified only when the daemon thread has added a token. The implementation of the <code class="mthd">getToken()</code> method is shown below:</p>

```python
    def getToken(self):
        self.cond.acquire()
        while self.possibleTokens == 0:
            self.cond.wait()
        self.possibleTokens = self.possibleTokens-1;
        self.cond.release();

        print("Granting " + threading.current_thread().getName() + " token at " + str(datetime.now()));
```

<p>Note that we are manipulating the shared mutable variable <code class="mthd">possibleTokens</code> in a critical section. Additionally, we <code class="mthd">wait()</code> when the number of tokens is zero. The implementation of the daemon thread is given below. It runs in a perpetual loop.</p>

```python
    def daemonThread(self):
        while True:
            self.cond.acquire()
            if self.possibleTokens < self.MAX_TOKENS:
                self.possibleTokens = self.possibleTokens + 1;
            self.cond.notify() 
            self.cond.release()
            
            time.sleep(self.ONE_SECOND);
```

<p>The complete implementation along with a test-case appears in the code widget below:</p>

</div>

<div>
# Using a Background Thread

<p>The previous solution consisted of manipulating pointers in time, thus avoiding threads altogether. Another solution is to use threads to solve the token bucket filter problem. We instantiate one thread to add a token to the bucket after every one second. The user thread invokes the <code>getToken()</code> method and is granted one if available. We instantiate one thread to add a token to the bucket after every one second. The user thread invokes the <code>getToken()</code> method and is granted one if available. </p>

<p>One simplification as a result of using threads is we now only need to remember the current number of tokens held by the token bucket filter object. We'll add an additional method <code>daemonThread()</code> that will be executed by the thread that adds a token every second to the bucket. The skeleton of our class looks as follows:</p>

```python
class MultithreadedTokenBucketFilter(TokenBucketFilter):
    def __init__(self, maxTokens):
        self.MAX_TOKENS = int(maxTokens)
        self.possibleTokens  = int(0)
        self.ONE_SECOND = int(1)
        self.cond = Condition()

    def daemonThread(self):

    def getToken(self):

```
<br/>
<p>The logic of the daemon thread is simple. It sleeps for one second, wakes up, checks if the number of tokens in the bucket is less than the maximum allowed tokens, if yes increments the <code>possibleTokens</code> variable and if not goes back to sleep for a second again.</p>

<p>The implementation of the <code>getToken()</code> is even simpler. The user thread checks if the number of tokens is greater than zero, if yes it simulates taking away a token by decrementing the variable <code>possibleTokens</code>.  If the number of available tokens is zero then the user thread must wait and be notified only when the daemon thread has added a token. The implementation of the <code>getToken()</code> method is shown below:</p>

```python
    def getToken(self):
        self.cond.acquire()
        while self.possibleTokens == 0:
            self.cond.wait()
        self.possibleTokens = self.possibleTokens-1;
        self.cond.release();

        print("Granting " + threading.current_thread().getName() + " token at " + str(datetime.now()));
```

<p>Note that we are manipulating the shared mutable variable <code>possibleTokens</code> in a critical section. Additionally, we <code>wait()</code> when the number of tokens is zero. The implementation of the daemon thread is given below. It runs in a perpetual loop.</p>

```python
    def daemonThread(self):
        while True:
            self.cond.acquire()
            if self.possibleTokens < self.MAX_TOKENS:
                self.possibleTokens = self.possibleTokens + 1;
            self.cond.notify() 
            self.cond.release()
            
            time.sleep(self.ONE_SECOND);
```

<p>The complete implementation along with a test-case appears in the code widget below:</p>

</div>

The Basics

Threading Module

Multiprocessing

Concurrent Package

Async.io

Global Interpreter Lock

Interview Practise Problems

The End

... continued

Using a Background Thread