Lazy Futures with Coroutines

Based on the coroutines-based implementation of a simple future in my last post "Implementing Simple Futures with Coroutines", I want to go today one big step further. I analyze the workflow of the simple future and make it lazy.

Read more
Views: 5494

Implementing Simple Futures with Coroutines

Instead of return, a coroutine uses co_return returning its result. In this post, I want to implement a simple coroutine using co_return.

Read more
Views: 9086

Synchronized Output Streams with C++20

What happens when you write without synchronization to std::cout? You get a mess. With C++20, this should not be anymore.

Read more
Views: 6894

The Five (Seven) Winners of my C++20 book are:

Last week, I launched a quiz. The price was it to win one of the five vouchers for my book "C++20".

Read more
Views: 2354

An Improved Thread with C++20

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.

Read more
Views: 50236

Resolving C/C++ Concurrency Bugs More Efficiently with Time Travel Debugging

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

Read more
Views: 6432

Cooperative Interruption of a Thread in C++20

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.

Read more
Views: 4258

Five Vouchers to win for my book "C++20"

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?

Read more
Views: 3606

Barriers and Atomic Smart Pointers in C++20

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.

Read more
Views: 6512

Latches in C++20

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.

Read more
Views: 65103

My Newest E-Books

Course: Modern C++ Concurrency in Practice

Course: C++ Standard Library including C++14 & C++17

Course: Embedded Programming with Modern C++

Course: Generic Programming (Templates)

Course: C++ Fundamentals for Professionals

Subscribe to the newsletter (+ pdf bundle)

Blog archive

Source Code

Visitors

Today 4790

Yesterday 6581

Week 41146

Month 100775

All 6329247

Currently are 173 guests and no members online

Kubik-Rubik Joomla! Extensions

Latest comments