The ultimate guide to Ruby concurrency interviews. Developed by FAANG engineers, this course covers Monitors, Deferred Callbacks and problem-solving strategies for Reader-Writer and Dining Philosopher Problems.

Concurrency in Ruby 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 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 basics of Ruby would be helpful.

Ruby Concurrency for Senior Engineering Interviews

<div class="ans">
# Mutex Implementation
<p>In the previous section we implemented the consumer-producer problem using a mutex and condition variable pair and later using a monitor and condition variable pair. Both of them are the right approaches to solve the problem but for instructional purposes, let's see how we can solve the problem just using a mutex which includes busy waiting.</p>

<p>Let's consider the <code class="mthd">producer()</code> method. We need to check for the size of the queue while holding the mutex lock since queue is a shared data-structure. Say the queue is full and the producer thread needs to wait, but we don't have a condition variable to wait on. The only solution is to continuously check for the predicate to become true in a loop. However, if we don't let go of the mutex, the consumer thread will never get a chance to change the predicate. The trick is to unlock and then immediately lock the mutex again before spinning in the while loop. In between the two actions, the consumer thread should get a chance to acquire the lock and change the predicate. Note that we must lock the mutex every time we check the predicate in the while loop. The complete code for the <code class="mthd">producer()</code> method appears below:</p>

```ruby
  def producer(elem)
    @mutex.lock()

    while @queue.size == @queue_capacity
      # puts "Oh no! The queue is full, Please wait.."
      # give chance to consumer to acquire lock
      @mutex.unlock()
      # make sure to acquire lock before checking
      # predicate
      @mutex.lock()
    end

    # Adds an element to the end of the queue
    @queue << elem
    puts "Added #{elem} to the queue"
    @mutex.unlock()
  end
```

<p>The complete code for the producer-consumer problem using only a mutex appears below:</p>
</div>

<div>
# Mutex Implementation
<p>In the previous section we implemented the consumer-producer problem using a mutex and condition variable pair and later using a monitor and condition variable pair. Both of them are the right approaches to solve the problem but for instructional purposes, let's see how we can solve the problem just using a mutex which includes busy waiting.</p>

<p>Let's consider the <code>producer()</code> method. We need to check for the size of the queue while holding the mutex lock since queue is a shared data-structure. Say the queue is full and the producer thread needs to wait, but we don't have a condition variable to wait on. The only solution is to continuously check for the predicate to become true in a loop. However, if we don't let go of the mutex, the consumer thread will never get a chance to change the predicate. The trick is to unlock and then immediately lock the mutex again before spinning in the while loop. In between the two actions, the consumer thread should get a chance to acquire the lock and change the predicate. Note that we must lock the mutex every time we check the predicate in the while loop. The complete code for the <code>producer()</code> method appears below:</p>

```ruby
  def producer(elem)
    @mutex.lock()

    while @queue.size == @queue_capacity
      # puts "Oh no! The queue is full, Please wait.."
      # give chance to consumer to acquire lock
      @mutex.unlock()
      # make sure to acquire lock before checking
      # predicate
      @mutex.lock()
    end

    # Adds an element to the end of the queue
    @queue << elem
    puts "Added #{elem} to the queue"
    @mutex.unlock()
  end
```

<p>The complete code for the producer-consumer problem using only a mutex appears below:</p>
</div>

This lesson demonstrates how to implement consumer-producer problem using mutexes.

The Basics

API Overview

Brief Intro to Asynchronous Programming

Interview Practice Problems

Bonus Questions

Epilogue

... continued

Mutex Implementation