CPP Concurrency & Multithreading 2

Question 1

Which C++ standard introduced `std::atomic` and the memory model?

Accepted Answer

C++11

Answer

C++11 introduced `std::atomic`, `std::thread`, and a formal memory model for concurrent programming.

Question 2

What does `std::memory_order_acquire` guarantee when used in a load operation?

Accepted Answer

All subsequent reads/writes in the current thread see effects from the release store they synchronized with

Answer

`memory_order_acquire` ensures that subsequent reads and writes in the current thread cannot be reordered before this load, forming the acquire side of a release-acquire pair.

Question 3

What is a spurious wakeup in the context of `std::condition_variable`?

Accepted Answer

A wakeup that occurs without any thread calling notify_one or notify_all

Answer

A spurious wakeup is when `wait()` returns without any thread having called `notify_one` or `notify_all`, which is why wait should always be used with a predicate.

Question 4

What is the difference between `std::lock_guard` and `std::unique_lock`?

Accepted Answer

`std::unique_lock` supports deferred locking, manual unlock, and timed locking; `std::lock_guard` is a simpler RAII wrapper

Answer

`std::unique_lock` provides more flexibility including deferred locking, try-locking, timed locking, and manual unlock/relock, while `std::lock_guard` is a lightweight non-movable RAII wrapper.

Question 5

What does `std::thread::detach()` do?

Accepted Answer

Allows the thread to run independently so its resources are freed automatically upon completion

Answer

`detach()` separates the thread of execution from the `std::thread` object, allowing the thread to run independently; its resources are reclaimed automatically when it finishes.

(CPP) C++ Programming Professional Certificate Practice Test

(CPP) C++ Programming Professional Certificate Practice Test

CPP Concurrency & Multithreading 2