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="card">
   # Blocking Queue | Bounded Buffer | Consumer Producer
    <div class="ans">
<p>A blocking queue is defined as a queue which blocks the caller of the enqueue method if there's no more capacity to add the new item being enqueued. Similarly, the queue blocks the dequeue caller if there are no items in the queue. Also, the queue notifies a blocked enqueuing thread when space becomes available and a blocked dequeuing thread when an item becomes available in the queue. </p>   
 </div>
</div>


<div class="card">
   # Solution
    <div class="ans">

<p>The bounded buffer is a classic textbook concurrency problem. We'll look at the various ways we can implement such a buffer.</p>

<p>Our queue will have a finite size that is passed in via the constructor. Additionally, we'll use an integer array as the data structure for backing our queue. We choose to use a simple integer array to make the example easier to follow. However, a solution with a generic container would follow the same underlying logic.</p>  

<p>Furthermore, we'll expose two APIs in our blocking queue class:</p>

<ul>
<li><code class="mthd">producer()</code></li>
<li><code class="mthd">consumer()</code></li>
</ul>

<p>We'll always add an element to the end of the array and remove an element from the first index of the array. Therefore, the end of the array is the tail of the queue and the start of the array is the head of the queue.</p>

```ruby
class BlockingQueue

  # this method declares a simple array as the data structure for blocking queue, 
  # mutex for synchronization and a condition variable for waiting and notifying
  def initialize(capacity)
    @queue_capacity = capacity
    @queue = Array.new()
    @mutex = Mutex.new
    @cond_var = ConditionVariable.new
  end

  # producer method that populates the queue and notifies the waiting threads
  def producer(elem)
  end

  # consumer method that either consumes items from the queue or waits until something is present
  def consumer
  end

end

```
</b>


<p>Let's start with the <code class="mthd">producer()</code> method that adds items into the queue. When should we block the producer? When the queue is at its maximum capacity. We can make the producer thread <code class="mthd">wait()</code> on the condition variable. However, remember, whenever we wait on a condition variable we must wrap the <code class="mthd">wait()</code> call in a while loop that tests for the predicate. This is to take care of spurious wakeups and ensure correct working in case of more than one producer threads. Moreover, since we check for the predicate in a while loop and also add items to the queue, both of which also get manipulated in the consumer code, we wrap the entire function body in a mutex lock. Lastly, whenever we add an item to the queue there may be consumer threads waiting on the condition variable, in case the queue was empty, so we must not forget to <code class="mthd">signal()</code> the condition variable to wakeup any such threads. The code for the method appears below:</p>

<b>

```ruby
def producer(elem)
  @mutex.synchronize do
    while @queue.size == @queue_capacity
      puts "Oh no! The queue is full,   Please wait.."
      @cond_var.wait(@mutex)
    end
     # Adds an element to the end of the queue
    @queue << elem
    puts "Added #{elem} to the queue"
    @cond_var.signal
  end
end
```
</b>

<p>Let's consider the <code class="mthd">consumer()</code> method now. The logic is complementary to the <code class="mthd">producer()</code> method. When should we block the consumer? When the queue is empty. That is the predicate we should check for in the while loop. Similarly, we should always <code class="mthd">signal()</code> the condition variable whenever an item is consumed from the queue because there might be a producer thread that is waiting on the condition variable in case the queue was full. Finally, we wrap the function body in the same mutex as the other method since we mutate shared data-structures. The code for the <code class="mthd">consumer()</code> method appears below:  </p> 
<b>

```ruby
def consumer
  @mutex.synchronize do
    while @queue.empty?
      puts "Oh no! The queue is empty, Please wait.."
      @cond_var.wait(@mutex)
    end
      # Retrieves the element at the first index
    puts "Consumed #{@queue.shift} from the queue"
    @cond_var.signal
  end
end     
```
</b>
</div>

<div class="ans">
## Complete Code
<p>The full code for the blocking queue appears below.</p>
<b>

```ruby
#A blocking queue class with initialize, producer and consumer methods
class BlockingQueue

  # this method declares a simple array as the data structure for blocking queue, mutex for synchronization and a condition variable for waiting and notifying
  def initialize(capacity)
    @queue_capacity = capacity
    @queue = Array.new()
    @mutex = Mutex.new
    @cond_var = ConditionVariable.new
  end

  # producer method that populates the queue and notifies the waiting threads
  def producer(elem)
    @mutex.synchronize do
      while @queue.size == @queue_capacity
        puts "Oh no! The queue is full, Please wait.."
        @cond_var.wait(@mutex)
      end
      # Adds an element to the end of the queue
      @queue << elem
      puts "Added #{elem} to the queue"
      @cond_var.signal
    end
  end

  # consumer method that either consumes items from the queue or waits until something is present
  def consumer
    @mutex.synchronize do
      while @queue.empty?
        puts "Oh no! The queue is empty, Please wait.."
        @cond_var.wait(@mutex)
      end
      # Retrieves the element at the first index
      puts "Consumed #{@queue.shift} from the queue"
      @cond_var.signal

    end
  end
end
```
</b>

<p>The test case, in our example, creates a thread that tries to consume from an empty queue. The consumer thread is blocked while the queue gets populated by the producer thread. The consumer thread is unblocked the moment an item is inserted into the queue. Another scenario tested is the queue reaching full capacity. The producer thread gets suspended unless one of the items is taken off the queue by the consumer thread.</p>
</div>

<div>
   # Blocking Queue | Bounded Buffer | Consumer Producer
    <div>
<p>A blocking queue is defined as a queue which blocks the caller of the enqueue method if there's no more capacity to add the new item being enqueued. Similarly, the queue blocks the dequeue caller if there are no items in the queue. Also, the queue notifies a blocked enqueuing thread when space becomes available and a blocked dequeuing thread when an item becomes available in the queue. </p>   
 </div>
</div>


<div>
   # Solution
    <div>

<p>The bounded buffer is a classic textbook concurrency problem. We'll look at the various ways we can implement such a buffer.</p>

<p>Our queue will have a finite size that is passed in via the constructor. Additionally, we'll use an integer array as the data structure for backing our queue. We choose to use a simple integer array to make the example easier to follow. However, a solution with a generic container would follow the same underlying logic.</p>  

<p>Furthermore, we'll expose two APIs in our blocking queue class:</p>

<ul>
<li><code>producer()</code></li>
<li><code>consumer()</code></li>
</ul>

<p>We'll always add an element to the end of the array and remove an element from the first index of the array. Therefore, the end of the array is the tail of the queue and the start of the array is the head of the queue.</p>

```ruby
class BlockingQueue

  # this method declares a simple array as the data structure for blocking queue, 
  # mutex for synchronization and a condition variable for waiting and notifying
  def initialize(capacity)
    @queue_capacity = capacity
    @queue = Array.new()
    @mutex = Mutex.new
    @cond_var = ConditionVariable.new
  end

  # producer method that populates the queue and notifies the waiting threads
  def producer(elem)
  end

  # consumer method that either consumes items from the queue or waits until something is present
  def consumer
  end

end

```
</b>


<p>Let's start with the <code>producer()</code> method that adds items into the queue. When should we block the producer? When the queue is at its maximum capacity. We can make the producer thread <code>wait()</code> on the condition variable. However, remember, whenever we wait on a condition variable we must wrap the <code>wait()</code> call in a while loop that tests for the predicate. This is to take care of spurious wakeups and ensure correct working in case of more than one producer threads. Moreover, since we check for the predicate in a while loop and also add items to the queue, both of which also get manipulated in the consumer code, we wrap the entire function body in a mutex lock. Lastly, whenever we add an item to the queue there may be consumer threads waiting on the condition variable, in case the queue was empty, so we must not forget to <code>signal()</code> the condition variable to wakeup any such threads. The code for the method appears below:</p>

<b>

```ruby
def producer(elem)
  @mutex.synchronize do
    while @queue.size == @queue_capacity
      puts "Oh no! The queue is full,   Please wait.."
      @cond_var.wait(@mutex)
    end
     # Adds an element to the end of the queue
    @queue << elem
    puts "Added #{elem} to the queue"
    @cond_var.signal
  end
end
```
</b>

<p>Let's consider the <code>consumer()</code> method now. The logic is complementary to the <code>producer()</code> method. When should we block the consumer? When the queue is empty. That is the predicate we should check for in the while loop. Similarly, we should always <code>signal()</code> the condition variable whenever an item is consumed from the queue because there might be a producer thread that is waiting on the condition variable in case the queue was full. Finally, we wrap the function body in the same mutex as the other method since we mutate shared data-structures. The code for the <code>consumer()</code> method appears below:  </p> 
<b>

```ruby
def consumer
  @mutex.synchronize do
    while @queue.empty?
      puts "Oh no! The queue is empty, Please wait.."
      @cond_var.wait(@mutex)
    end
      # Retrieves the element at the first index
    puts "Consumed #{@queue.shift} from the queue"
    @cond_var.signal
  end
end     
```
</b>
</div>

<div>
## Complete Code
<p>The full code for the blocking queue appears below.</p>
<b>

```ruby
#A blocking queue class with initialize, producer and consumer methods
class BlockingQueue

  # this method declares a simple array as the data structure for blocking queue, mutex for synchronization and a condition variable for waiting and notifying
  def initialize(capacity)
    @queue_capacity = capacity
    @queue = Array.new()
    @mutex = Mutex.new
    @cond_var = ConditionVariable.new
  end

  # producer method that populates the queue and notifies the waiting threads
  def producer(elem)
    @mutex.synchronize do
      while @queue.size == @queue_capacity
        puts "Oh no! The queue is full, Please wait.."
        @cond_var.wait(@mutex)
      end
      # Adds an element to the end of the queue
      @queue << elem
      puts "Added #{elem} to the queue"
      @cond_var.signal
    end
  end

  # consumer method that either consumes items from the queue or waits until something is present
  def consumer
    @mutex.synchronize do
      while @queue.empty?
        puts "Oh no! The queue is empty, Please wait.."
        @cond_var.wait(@mutex)
      end
      # Retrieves the element at the first index
      puts "Consumed #{@queue.shift} from the queue"
      @cond_var.signal

    end
  end
end
```
</b>

<p>The test case, in our example, creates a thread that tries to consume from an empty queue. The consumer thread is blocked while the queue gets populated by the producer thread. The consumer thread is unblocked the moment an item is inserted into the queue. Another scenario tested is the queue reaching full capacity. The producer thread gets suspended unless one of the items is taken off the queue by the consumer thread.</p>
</div>

Classical synchronization problem involving a limited size buffer which can have items added to it or removed from it by different producer and consumer threads. This problem is known by different names: blocking queue problem, bounded buffer problem or consumer producer problem.

The Basics

API Overview

Brief Intro to Asynchronous Programming

Interview Practice Problems

Bonus Questions

Epilogue

Blocking Queue | Bounded Buffer | Consumer Producer

Blocking Queue | Bounded Buffer | Consumer Producer