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">
   # Condition Variables   
   <div class="ans">
<p>Synchronization mechanisms need more than just mutual exclusion; a general need is to be able to wait for another thread to do something. Condition variables provide mutual exclusion and the ability for threads to wait for a predicate to become true.</p>

<p>Condition variables is always associated with a lock and in case of Ruby that lock is an instance of the <code class="clazz">Mutex</code> class. Using condition variables allows us to rid ourselves of writing busy-wait loops that constantly poll for a condition to become true. </p>

<p>The <code class="clazz">Condition</code> class can be used to create an instance of a condition variable. Note that we'll also need to create a mutex object to work in conjunction with the condition variable.</p>

```ruby
cv = ConditionVariable.new
mutex = Mutex.new
```
## wait
<p>The <code class="mthd">wait()</code> method accepts a mutex object as an argument. The idiomatic usage of a condition variable requires us to first synchronize on the mutex object and then invoke <code class="mthd">wait()</code> on the condition variable while passing in the same mutex object that we synchronized on. The idiomatic usages are as follows:</p>

```ruby
mutex.lock()
cv.wait(mutex)
puts "statement executed when cv is signaled"
mutex.unlock()
```
<p><span class="hi-yl">A thread gives up the mutex associated with the condition variable when it invokes <code class="mthd">wait()</code> on the condition variable. The mutex lock is reacquired by the thread when the condition variable is signaled.</p> 

<p>Consider the code widget below, where we try to wait on the condition variable without locking the mutex first. When the code widget is run, it throws an exception.</p>


</div>
</div>

<div>
   # Condition Variables   
   <div>
<p>Synchronization mechanisms need more than just mutual exclusion; a general need is to be able to wait for another thread to do something. Condition variables provide mutual exclusion and the ability for threads to wait for a predicate to become true.</p>

<p>Condition variables is always associated with a lock and in case of Ruby that lock is an instance of the <code>Mutex</code> class. Using condition variables allows us to rid ourselves of writing busy-wait loops that constantly poll for a condition to become true. </p>

<p>The <code>Condition</code> class can be used to create an instance of a condition variable. Note that we'll also need to create a mutex object to work in conjunction with the condition variable.</p>

```ruby
cv = ConditionVariable.new
mutex = Mutex.new
```
## wait
<p>The <code>wait()</code> method accepts a mutex object as an argument. The idiomatic usage of a condition variable requires us to first synchronize on the mutex object and then invoke <code>wait()</code> on the condition variable while passing in the same mutex object that we synchronized on. The idiomatic usages are as follows:</p>

```ruby
mutex.lock()
cv.wait(mutex)
puts "statement executed when cv is signaled"
mutex.unlock()
```
<p><span>A thread gives up the mutex associated with the condition variable when it invokes <code>wait()</code> on the condition variable. The mutex lock is reacquired by the thread when the condition variable is signaled.</p> 

<p>Consider the code widget below, where we try to wait on the condition variable without locking the mutex first. When the code widget is run, it throws an exception.</p>


</div>
</div>

This lesson explores the use of condition variables in Ruby.

The Basics

API Overview

Brief Intro to Asynchronous Programming

Interview Practice Problems

Bonus Questions

Epilogue

Condition Variables

Condition Variables