Info
This post was imported from a personal note. It may contain inside jokes, streams of consciousness, errors, and other nonsense.
Wow the speed up and slow down during screen capture is horrrible. Wowee. Look at this:
Actually, probably what I need is … multi-threading!
Studying for Multithreading #
std::mutex: “mutual exclusion.” Used to protect a resource that is shared by multiple threads from being accessed simultaneously. E.g., you might have a vector which one thread is writing to while the other is reading, which can result in loss of data integrity. A mutex has functions lock and try_lock which a thread can call to ensure it has exclusive access to the resource until unlock is called. The mutex doesn’t protect the actual resource itself, the coder is responsible for ensuring that the resource is not accessed outside of mutex lock.
https://en.cppreference.com/w/cpp/thread/mutex
std:lock_guard: A convenience class for taking ownership of a mutex within a scope and automatically unlocking the mutex when lock_guard is destroyed when leaving the scope.
“Resource Acquisition Is Initialization or RAII, is a C++ programming technique…”
https://en.cppreference.com/w/cpp/language/raii
Helps avoid resource leaks by tying the allocation of a resource to the current scope instead of requiring lock() / unlock() or open() / close() calls. Those non-RAII techniques are more likely to produce errors where the resource is never unlocked or closed because of code branching or early return statements, etc.
std::atomic wraps a value to ensure that accessing it from different threads does not cause data races. E.g., if two threads write a non-atomic value at the same time the behaviour is undefined (you never know what value you’re gonna get, it might not even be one of the values written by the two threads). std::atomic will ensure that one write finishes before the other begins, preventing this unknown behaviour.
Data races vs. Race conditions. These are not the same. Data races can sometimes cause race conditions but not necessarily. They can both happen on their own. One is not a subset of the other. Data races are when two processes try to access the same memory simultaneously. Race conditions are when a program loses integrity because the order in which multiple threads executed their code is unexpected.
Feel like there’s a better way to define that but I’ll sit on that for now.
std::condition_variable