Behavior vs Data concurrency protection

Multithreading is one of the hottest topics in C++. However, the most crucial question isn't just about running code across a vast number of cores, but rather how to synchronize all those threads effectively.

Synchronization can be broadly categorized into two main areas: data protection and behavior protection.

Data Protection Against Concurrent Access

Data protection is relatively straightforward. Consider a scenario where multiple threads share a variable—one thread writes to it while others read from it simultaneously, as illustrated below:

To ensure data integrity, this shared variable must be protected against concurrent access using synchronization primitives like mutexes, atomic variables, or other mechanisms. But why? While the standard mandates this, the underlying reason lies in processor architecture.

A CPU core doesn't interact directly with RAM for every read and write operation. Instead, it relies on cache memory, as shown below:

This caching mechanism means that two cores could hold copies of the same variable in their caches and update them independently. To prevent data inconsistency and ensure correct behavior, synchronization primitives are used, as in the following example:

Behavior Protection Against Concurrent Access

Behavior protection is more complex. Sometimes, a series of operations must be executed sequentially by a single thread, as depicted below:

While mutexes can be applied here as well:

This approach, while effective, can make the codebase more complex and error-prone. During refactoring, it's easy to accidentally move a variable outside of its mutex protection, introducing bugs.

A better approach in some cases is to refactor behavior synchronization. Where feasible, behavior synchronization can be transformed into data synchronization. In many cases, delegating tasks to a dedicated thread using a task queue is a more efficient solution, as shown below:

Libraries like Boost.Asio and Qt are useful here. For example, with Boost.Asio, you could implement the following:

With that example, the code is much cleaner and requires no explicit synchronization for multiple threads, as all operations are executed in a single thread.

Conclusion

In a multithreading environment, it's important to protect data against concurrent access. However, for situations where multiple operations need to be executed atomically, consider using a dedicated thread with a task queue. This approach simplifies synchronization and reduces the number of bugs.