Skip to content
New this month 24 fresh C++, C#, F#, JavaScript, TypeScript and Lua courses just landed. Browse new releases Use code WELCOME10 for 10% off your first order · 14-day refund
WisdomCharms — home
Cart 0 items in cart
Systems & Low-Level Advanced

Concurrency Without Fear: Threads, Locks, Channels and Async

Four concurrency models compared side by side, with the bugs reproduced and fixed.

Rated 4.5 out of 5 from 2 reviews 22 students

AP Created by Ana Petrova

  • Last updated August 2026
  • English
  • 3h 34m of material
  • 27 lessons

What you will learn

8 concrete outcomes

Every bullet below is something you will have built, shipped or be able to explain by the time you finish the last lesson.

  • Reproduce and fix data races, deadlocks and livelocks deliberately
  • Explain memory ordering and use acquire and release semantics correctly
  • Compare locks, channels, ownership-based threading and task-based async fairly
  • Build a bounded queue with backpressure and a worker pool in each model
  • Implement cancellation, timeouts and graceful shutdown that actually complete
  • Measure throughput and tail latency rather than assuming a model is faster
  • Design away shared mutable state with sharding and single-writer patterns
  • Choose the right model for a given workload and justify the decision

Course curriculum

5 modules · 27 lessons · 3h 34m of material

6 lessons running 48m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

6 lessons running 46m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

5 lessons running 40m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

5 lessons running 40m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

5 lessons running 40m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

5 modules · 27 lessons

3h 34m total length

Requirements

Short list, and deliberately so. If you meet these you can start today.

  • Solid experience in at least one of C++, Go, Rust or C#
  • Toolchains installed for the languages you intend to follow along in
  • Prior exposure to threads or async, even if it went badly

About this course

Concurrency is usually taught inside one language, which hides the fact that most difficulty is in the model rather than the syntax. This course teaches four models next to each other, shared memory with locks in C++, channels and goroutines in Go, ownership-enforced threading in Rust, and task-based async in C#, using the same problem in each so the trade-offs are visible.

The first modules establish what actually goes wrong. Data races are reproduced under a race detector, deadlocks are constructed on purpose and then prevented with lock ordering, and you see why a benign-looking read without synchronisation is not benign at all once the compiler and processor are free to reorder. Atomics and memory ordering are explained at the level a working developer needs, with acquire and release framed as visibility guarantees rather than as incantations.

The applied half builds the same pipeline four times: a bounded queue with backpressure, a worker pool, cancellation and timeouts, and graceful shutdown. You measure throughput and tail latency for each, then close with the patterns that avoid shared mutable state altogether, immutability, message passing, sharding and single-writer designs.

Topics covered

Frequently asked questions

Still unsure about something? Write to misteryjj100@gmail.com and a human answers, usually the same working day.

No. Each model has a primary language but the concepts and diagrams stand alone, and most learners follow along in one or two and read the rest.

It assumes you already write concurrent code and want the model behind the failures. If threads are entirely new, start with the concurrency chapter of your language course first.

Only where it overlaps, such as backpressure and cancellation. Consensus and replication are a different subject and are not part of this course.

Checkout is handled on our provider's secure payment page. The moment your payment clears we email your personal access link and access code to the address you used at checkout, and the same link appears in your account library. There is nothing to install and nothing to wait for.

Email misteryjj100@gmail.com within 14 days of your purchase, quote your order number, and we refund the full amount to your original payment method. No form to fill in and no questions about how much of the course you watched.

What students say

Reviews are written by people who bought this course. We publish the critical ones too.

4.5

Rated 4.5 out of 5

Course rating · 2 reviews

Rating distribution

  • 5 stars 50%
  • 4 stars 50%
  • 3 stars 0%
  • 2 stars 0%
  • 1 star 0%
  • IG

    Ivan Georgiev

    Systems engineer

    Feb 2026
    Rated 5.0 out of 5

    One problem, four models, side by side

    Solving an identical producer-consumer problem four separate ways is the best possible structure for this subject. You stop arguing about which model is correct and start seeing plainly what each one costs you.
  • AB

    Anja Bergström

    Software engineer

    Oct 2025
    Rated 4.0 out of 5

    The memory ordering chapter is a wall

    Races and deadlocks are taught brilliantly, with each bug actually reproduced on screen rather than described. Then acquire and release ordering arrives and the difficulty spikes hard for one chapter with no ramp into it. I got through on a second viewing, but it is a noticeable seam.

Your instructor

AP

Ana Petrova

Systems engineer and C++ instructor

  • 206 students taught
  • 9 courses published
  • 4.4 instructor rating
  • C++
  • Systems programming
  • Memory management
  • Concurrency

Ana spent nine years writing real-time C++ for trading infrastructure before moving into teaching full time. She specialises in the parts of the language people quietly avoid: templates, move semantics, custom allocators and the memory model. Her courses are built around profiling sessions on code that is deliberately slow, so every fix is something you measure rather than memorise. She still contributes to two open-source benchmarking libraries.

See every course by Ana Petrova
$19 USD

One-time payment · lifetime access

The WisdomCharms dispatch

One useful email a week. No fluff, no spam.

New course releases, discount codes before anyone else, and a short, practical breakdown of one technique — a prompt pattern, a C++ idiom, a TypeScript trick — that you can use the same day.

  • Subscriber-only launch pricing
  • Unsubscribe in one click
  • We never sell your address

By subscribing you agree to our Privacy Policy. Questions? Write to misteryjj100@gmail.com.