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">
   # Monitor   
   <div class="ans">

<p>We have discussed the general concept of a monitor in a previous lesson and now we'll see Ruby's implementation of a monitor. A monitor provides mutual exclusion and the ability for a thread to wait on one or more condition variables.</p>

<p>We can create a monitor as follows:</p>

```ruby
monitor = Monitor.new
```
<p>For mutual exclusion, we can use instance methods <code class="mthd">enter()</code> and <code class="mthd">exit()</code> to wrap a block of code. For instance:</p>

```ruby
monitor = Monitor.new

monitor.enter()
#... critical section
monitor.exit()
```
<p>Or we can use <code class="clazz">synchronize</code> alias on the monitor object, which automatically enters and exits the monitor for us. For instance:</p>

```ruby
monitor = Monitor.new

monitor.synchronize {
    #... critical section
}
```
<p>It is preferable to use the alias with the monitor object because it will ensure that the monitor's <code class="mthd">exit()</code> method is invoked even if the critical section raises an exception.</p>

<p>We can create condition variables associated with a monitor as follows:</p>

```ruby
monitor = Monitor.new
cv = monitor.new_cond()
```
<p>With these building blocks, let's write a program with two threads. The main thread spawns a child that waits on the monitor's condition variable which is signaled by the main thread. The code appears in the code widget below:</p>
</div>
</div>

<div>
   # Monitor   
   <div>

<p>We have discussed the general concept of a monitor in a previous lesson and now we'll see Ruby's implementation of a monitor. A monitor provides mutual exclusion and the ability for a thread to wait on one or more condition variables.</p>

<p>We can create a monitor as follows:</p>

```ruby
monitor = Monitor.new
```
<p>For mutual exclusion, we can use instance methods <code>enter()</code> and <code>exit()</code> to wrap a block of code. For instance:</p>

```ruby
monitor = Monitor.new

monitor.enter()
#... critical section
monitor.exit()
```
<p>Or we can use <code>synchronize</code> alias on the monitor object, which automatically enters and exits the monitor for us. For instance:</p>

```ruby
monitor = Monitor.new

monitor.synchronize {
    #... critical section
}
```
<p>It is preferable to use the alias with the monitor object because it will ensure that the monitor's <code>exit()</code> method is invoked even if the critical section raises an exception.</p>

<p>We can create condition variables associated with a monitor as follows:</p>

```ruby
monitor = Monitor.new
cv = monitor.new_cond()
```
<p>With these building blocks, let's write a program with two threads. The main thread spawns a child that waits on the monitor's condition variable which is signaled by the main thread. The code appears in the code widget below:</p>
</div>
</div>

This lesson introduces the use of Monitor in Ruby.

The Basics

API Overview

Brief Intro to Asynchronous Programming

Interview Practice Problems

Bonus Questions

Epilogue

Monitor

Monitor