std::jthread stands for joining thread. In addition to std::thread (C++11), std::jthread automatically joins in its destructor and can cooperatively be interrupted. Read in this post to know why std::jthread should be your first choice.

I'm happy to announce a guest post about Time Travel Debugging with UDB. At the end of the post, I have a bonus.

A typical question in my C++ seminars is: Can A  thread be killed?. Before C++20, my answer is no. With C++20, you can ask a thread politely for its interruption.

I give away five vouchers for my book "C++20". In return, I have a question about the Big Four: concepts, ranges, coroutines, and modules. Which feature excites your most and why?

In my last post, I introduced latches in C++20. A latch enables its threads to wait until a counter becomes zero. Additionally, to a latch, its big sibling barrier can be used more than once. Today, I write about barriers and present atomic smart pointers.

Latches and barriers are coordination types that enable some threads to wait until a counter becomes zero. You can use a std::latch only once, but you can use a std::barrier more than once. Today, I have a closer look at latches.

Semaphores are a synchronization mechanism used to control concurrent access to a shared resource. They also allow it to play ping-pong.

Last week,  I launched a quiz. The price was it to win one of the five vouchers for the book "The Modern C++ Programming Cookbook" 2en Edition by Marius Bancila.

After the introduction to std::atomic_flag in my last post Synchronization with Atomics in C++20, I want to dive deeper. Today, I create a ping-pong game using condition variables, std::atomic_flag, and std::atomic<bool>. Let's play.

Sender/receiver workflows are quite common for threads. In such a workflow, the receiver is waiting for the sender's notification before it continues to work. There are various ways to implement these workflows. With C++11, you can use condition variables or promise/future pairs; with C++20, you can use atomics.