cs_libguarded VS concurrencpp

I know this article was trying to come up with an excuse to use a shared_ptr, but atomic smart pointers are a lot more error prone than wrapping mutexes in an appropriate interface that hides the complexity and forces you to use them correctly.

The approach I would recommend would be to use mutexes but wrap them in a convenience library designed to make them difficult to misuse: https://github.com/copperspice/cs_libguarded

I was inspired by the great copperspice library libguarded and wanted something similar for when I have to go back to micro's and FreeRTOS. The basic idea of the library is to prevent access to a shared data structure unless the mutex lock associated with it is also acquired. This is to prevent situations where someone forgets to get the lock before reading or writing to shared memory.

I'm personally partial to the basic guarded type from https://github.com/copperspice/cs_libguarded due to its simplicity.

The Rust strategy for mutexes sounds a lot like libguarded, which now that I've read this article is occurs to me that the former was likely have been the inspiration for the latter.

This is pretty much what libguarded does.

Also I don't think that operating this way is good to begin with. See how libGuard operates - it is way way cleaner and more flexible https://github.com/copperspice/cs_libguarded

have you heard of https://github.com/copperspice/cs_libguarded ? it sounds like a similar idea, but supports other stuff like rcu as well

https://github.com/copperspice/cs_libguarded#cslibguarded

I am using concurrencpp for my project. What I like about it is that it's basically a thread pool factory with coroutines. It allows for better structuring / organizing of multithreaded work. So for me the main advantage of coroutines is that the code looks easier to follow

Equivalent concurrencpp code:

I agree. I use concurrencpp for the exact use case you described - coroutines running on simple-to-understand-executors which return some asynchronous pipe for communication.

If you look at concurrencpp, you can control exactly where and how coroutines are resumed, using executors.

concurrencpp. Modern concurrency for C++. Tasks, executors, timers and C++20 coroutines to rule them all.

Just use a good third party library like concurrencpp .

Hi, I am looking for a header-only C++14 (or lower) quality thread pool. Ideally, it would be similar to BS::thread_pool but in C++14. Most of them I find on GitHub are bloated (e.g. concurrencpp) or have many open Issues. Ideal usage would be similar to:

I use concurrencpp for my asynchronous code and the repo is written in modern cpp, with tests, sanitizers and what not.