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">
# Semaphore Implementation

<p>We can also implement the bounded buffer problem using a semaphore. Since Ruby's core library doesn't have a semaphore, we'll use the semaphore implementation from the previous lesson. Let's revisit our CountingSemaphore's constructor. It takes in the maximum number of permits. We can use two semaphores, one <code class="mthd">semConsumer</code> and the other <code class="mthd">semProducer</code>. The trick is to initialize <code class="mthd">semProducer</code> semaphore with the maximum queue capacity of N. This allows producer threads to enqueue N items in the queue. However, the <code class="mthd">semProducere</code> is only released/incremented by a consumer thread whenever it consumes an item. If there are no consumer threads, the producer threads will block when the buffer size becomes N. For the consumer thread code, initially, the buffer is empty. We would want to block any consumer threads on a <code class="mthd">consumer()</code> method call. This implies that we should initialize the <code class="mthd">semConsumer</code> with zero permits and a maximum size of N, since the producers can't put more than N items in the buffer. Given our implementation of the <code class="clazz">CountingSemaphore</code> we can do that by simply acquiring all the consumer permits in the <code class="mthd">initialize()</code> method of the <code class="clazz">BlockingQueue</code> class. Let's look at the implementation of <code class="mthd">producer()</code> method.</p>

```ruby
  def producer(elem)

    @semProducer.acquire()

    # Adds an element to the end of the queue
    @queue << elem
    puts "Added #{elem} to the queue"

    @semConsumer.release()
  end
```

<p>If you study the code above, it should be evident that only N items can be enqueued in the items buffer. At the end of the method, we signal any consumer threads waiting on the <code class="mthd">semConsumer</code> semaphore. However, the code is not yet complete. We have only solved the problem of coordinating between the threads. The astute reader would immediately realize that multiple producer threads can manipulate the code lines between the first and the last semaphore statements in the above <code class="mthd">producer()</code> method. In our earlier implementations, we were able to guard the critical section by locking a mutex or entering a monitor that ensured only a single thread is active in the critical section at a time. We need similar functionality using semaphores. Recall that we can use a binary semaphore in place of a mutex, however, any thread is free to signal the semaphore, not just the one that acquired it. We'll introduce a <code class="mthd">semLock</code> semaphore that acts as a mutex. The complete version of the enqueue() method appears below:</p>

```ruby
  def producer(elem)

    @semProducer.acquire()

    @semLock.acquire()
    # Adds an element to the end of the queue
    @queue << elem
    puts "Added #{elem} to the queue"
    @semLock.release()

    @semConsumer.release()
  end
```

<p>Realize that we have modeled each item in the buffer as a permit. When the buffer is full, the consumer threads have N permits to invoke <code class="mthd">consumer()</code> method and when the buffer is empty the producer threads have N permits to invoke <code class="mthd">producer()</code> method. The code for <code class="mthd">consumer()</code> is similar and appears below:</p>

```ruby
  def consumer
    @semConsumer.acquire()
    @semLock.acquire()
    # Retrieves the element at the first index
    puts "Consumed #{@queue.shift} from the queue"
    @semLock.release()
    @semProducer.release()
  end
```

<p>The complete code appears below.</p>

</div>

<div>
# Semaphore Implementation

<p>We can also implement the bounded buffer problem using a semaphore. Since Ruby's core library doesn't have a semaphore, we'll use the semaphore implementation from the previous lesson. Let's revisit our CountingSemaphore's constructor. It takes in the maximum number of permits. We can use two semaphores, one <code>semConsumer</code> and the other <code>semProducer</code>. The trick is to initialize <code>semProducer</code> semaphore with the maximum queue capacity of N. This allows producer threads to enqueue N items in the queue. However, the <code>semProducere</code> is only released/incremented by a consumer thread whenever it consumes an item. If there are no consumer threads, the producer threads will block when the buffer size becomes N. For the consumer thread code, initially, the buffer is empty. We would want to block any consumer threads on a <code>consumer()</code> method call. This implies that we should initialize the <code>semConsumer</code> with zero permits and a maximum size of N, since the producers can't put more than N items in the buffer. Given our implementation of the <code>CountingSemaphore</code> we can do that by simply acquiring all the consumer permits in the <code>initialize()</code> method of the <code>BlockingQueue</code> class. Let's look at the implementation of <code>producer()</code> method.</p>

```ruby
  def producer(elem)

    @semProducer.acquire()

    # Adds an element to the end of the queue
    @queue << elem
    puts "Added #{elem} to the queue"

    @semConsumer.release()
  end
```

<p>If you study the code above, it should be evident that only N items can be enqueued in the items buffer. At the end of the method, we signal any consumer threads waiting on the <code>semConsumer</code> semaphore. However, the code is not yet complete. We have only solved the problem of coordinating between the threads. The astute reader would immediately realize that multiple producer threads can manipulate the code lines between the first and the last semaphore statements in the above <code>producer()</code> method. In our earlier implementations, we were able to guard the critical section by locking a mutex or entering a monitor that ensured only a single thread is active in the critical section at a time. We need similar functionality using semaphores. Recall that we can use a binary semaphore in place of a mutex, however, any thread is free to signal the semaphore, not just the one that acquired it. We'll introduce a <code>semLock</code> semaphore that acts as a mutex. The complete version of the enqueue() method appears below:</p>

```ruby
  def producer(elem)

    @semProducer.acquire()

    @semLock.acquire()
    # Adds an element to the end of the queue
    @queue << elem
    puts "Added #{elem} to the queue"
    @semLock.release()

    @semConsumer.release()
  end
```

<p>Realize that we have modeled each item in the buffer as a permit. When the buffer is full, the consumer threads have N permits to invoke <code>consumer()</code> method and when the buffer is empty the producer threads have N permits to invoke <code>producer()</code> method. The code for <code>consumer()</code> is similar and appears below:</p>

```ruby
  def consumer
    @semConsumer.acquire()
    @semLock.acquire()
    # Retrieves the element at the first index
    puts "Consumed #{@queue.shift} from the queue"
    @semLock.release()
    @semProducer.release()
  end
```

<p>The complete code appears below.</p>

</div>

This lesson explains implementing a bounded buffer using Semaphores.

The Basics

API Overview

Brief Intro to Asynchronous Programming

Interview Practice Problems

Bonus Questions

Epilogue

... continued

Semaphore Implementation