cpp-thread-safety

Use std::scoped_lock for any mutex acquisition, especially when locking multiple mutexes, since it prevents deadlock from inconsistent lock ordering. Keep critical sections short with no I/O or callbacks held under the lock, and document the synchronization protocol above shared fields.

Pass owned values or immutable snapshots across thread boundaries instead of sharing mutable state. For Qt, emit signals with Qt::QueuedConnection and Q_DECLARE_METATYPE-registered argument types, and use QMetaObject::invokeMethod for UI-to-worker calls.

Use std::jthread because it auto-joins on destruction and supports cooperative cancellation through std::stop_token. std::thread::detach() is banned since detached threads can outlive the data they reference.

No, volatile is not a synchronization primitive in C++ and does not prevent data races. Use std::atomic<T> for shared flags and counters, defaulting to sequential consistency unless a weaker ordering is justified in writing.

Build and test with the dev-sanitize preset running AddressSanitizer, LeakSanitizer, and UBSan, then run the separate dev-tsan preset for ThreadSanitizer since ASan and TSan cannot combine. Never suppress sanitizer reports; fix the underlying ownership or synchronization defect.

Only with a written reason and a documented synchronization protocol specifying who locks what and in what order. Use std::shared_mutex when reads dominate, return values rather than references from locked accessors, and break shared_ptr cycles with std::weak_ptr.