Concurrency Interview

0%Certificate0/97

Join the Community

Introduction to Concurrency

Concurrency vs Parallelism

Processes vs Threads

Thread Lifecycle and States

Race Conditions and Critical Sections

Concurrency Models

Java

Creating Threads

Java Memory Model

Synchronized vs ReentrantLock

java.util.concurrent Package Tour

Virtual Threads

CompletableFuture Async Programming

Python

Creating Threads

Global Interpreter Lock (GIL)

Threading vs Multiprocessing

Asyncio Fundamentals

concurrent.futures Module

C++

Creating Threads

C++ Memory Model

std::atomic and Memory Orders

RAII for Concurrency

std::async, std::future, and std::promise

C#

Creating Threads

C# Memory Model

Lock, Monitor, and Synchronization

Task Parallel Library (TPL)

Async/Await Internals

Channels and Dataflow

Go

Creating Goroutines

Go Memory Model

Goroutines and Scheduler

Channels Fundamentals

Mutex (Mutual Exclusion)

Condition Variables

Read-Write Locks

Barriers and Latches

Synchronization Primitives - ExercisesNew

Lost Signal / Wakeup

Spurious Wakeup

Priority Inversion

Concurrency Challenges - ExercisesNew

Coarse-grained vs Fine-grained Locking

Reentrant Locks

Try-Lock and Timed Locking

Optimistic vs Pessimistic Locking

Two-Phase Locking

Locking Strategies - ExercisesNew

Compare-And-Swap (CAS)

Atomic Operations

Lock-Free Programming - ExercisesNew

Signaling Pattern

Thread Pool Pattern

Producer-Consumer Pattern

Reader-Writer Pattern

Future/Promise Pattern

Fork-Join Pattern

Double-Checked Locking Pattern

Concurrency Patterns - ExercisesNew

Interview Questions

Print Foo Bar Alternately

Print Zero Even Odd

Fizz Buzz Multithreaded

Building H2O Molecule

Readers-Writers Problem

Unisex Bathroom

Sleeping Barber

Dining Philosophers

Cigarette Smokers Problem

Santa Claus Problem

Synchronization Problems - ExercisesNew

Design Thread-Safe Cache with TTL

Design Thread-Safe Rate Limiter

Design Deferred Callback Executor

Design Ticket Booking System

Design Multithreaded Web Crawler

Design Multithreaded Pub-Sub System

Design Task Scheduler with Dependencies

Concurrency Design Problems - ExercisesNew

Design Concurrent HashMap

Design Thread-Safe Blocking Queue

Design Concurrent Bloom Filter

Design Lock-Free Queue

Design Concurrent Priority Queue

Design Thread-Safe Trie

Concurrent Data Structures - ExercisesNew

Multi-threaded Merge Sort

Multi-threaded Word Frequency Counter

Concurrent BFS/DFS Graph Traversal

Multi-threaded Algorithms - ExercisesNew

Concurrency Interview

Welcome

Course Roadmap
Join the Community

Concurrency 101

Introduction to Concurrency
Concurrency vs Parallelism
Processes vs Threads
Thread Lifecycle and States
Race Conditions and Critical Sections
Concurrency Models

Language Specific Concurrency

Creating Threads
Java Memory Model
Synchronized vs ReentrantLock
java.util.concurrent Package Tour
Virtual Threads
CompletableFuture Async Programming
Creating Threads
Global Interpreter Lock (GIL)
Threading vs Multiprocessing
Asyncio Fundamentals
concurrent.futures Module
Creating Threads
C++ Memory Model
std::atomic and Memory Orders
RAII for Concurrency
std::async, std::future, and std::promise
Creating Threads
C# Memory Model
Lock, Monitor, and Synchronization
Task Parallel Library (TPL)
Async/Await Internals
Channels and Dataflow
Creating Goroutines
Go Memory Model
Goroutines and Scheduler
Channels Fundamentals
sync Package

Synchronization Primitives

Mutex (Mutual Exclusion)
Semaphores
Condition Variables
Read-Write Locks
Barriers and Latches
Synchronization Primitives - Exercises

Concurrency Challenges

Deadlock
Livelock
Starvation
Lost Signal / Wakeup
Spurious Wakeup
Thread Leakage
Priority Inversion
Concurrency Challenges - Exercises

Locking Strategies

Coarse-grained vs Fine-grained Locking
Reentrant Locks
Try-Lock and Timed Locking
Optimistic vs Pessimistic Locking
Two-Phase Locking
Locking Strategies - Exercises

Lock-Free Programming

Compare-And-Swap (CAS)
Atomic Operations
Lock-Free Programming - Exercises

Concurrency Patterns

Signaling Pattern
Thread Pool Pattern
Producer-Consumer Pattern
Reader-Writer Pattern
Future/Promise Pattern
Fork-Join Pattern
Double-Checked Locking Pattern
Concurrency Patterns - Exercises

Synchronization Problems

Print Foo Bar Alternately
Print Zero Even Odd
Fizz Buzz Multithreaded
Building H2O Molecule
Readers-Writers Problem
Unisex Bathroom
Bounded Buffer
Sleeping Barber
Dining Philosophers
Cigarette Smokers Problem
Santa Claus Problem
Synchronization Problems - Exercises

Concurrency Design Problems

Design Thread-Safe Cache with TTL
Design Thread-Safe Rate Limiter
Design Deferred Callback Executor
Design Ticket Booking System
Design Multithreaded Web Crawler
Design Multithreaded Pub-Sub System
Design Task Scheduler with Dependencies
Concurrency Design Problems - Exercises

Concurrent Data Structures

Design Concurrent HashMap
Design Thread-Safe Blocking Queue
Design Concurrent Bloom Filter
Design Lock-Free Queue
Design Concurrent Priority Queue
Design Thread-Safe Trie
Concurrent Data Structures - Exercises

Multi-threaded Algorithms

Multi-threaded Merge Sort
Multi-threaded Word Frequency Counter
Concurrent BFS/DFS Graph Traversal
Multi-threaded Algorithms - Exercises

Cigarette Smokers Problem

Low Priority

Premium Content

Subscribe to unlock full access to this content and more premium articles.

Dining Philosophers Santa Claus Problem