{"id":4748,"date":"2016-05-12T20:29:00","date_gmt":"2016-05-12T20:29:00","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/prefer-locks-to-mutexes\/"},"modified":"2023-08-15T11:34:23","modified_gmt":"2023-08-15T11:34:23","slug":"prefer-locks-to-mutexes","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/prefer-locks-to-mutexes\/","title":{"rendered":"Prefer Locks to Mutexes"},"content":{"rendered":"

If the previous post <\/a>showed something, it’s that you should use mutexes with great care. That’s why you should wrap them in a lock.<\/p>\n

<\/p>\n

Locks<\/h2>\n

Locks take care of their resource following the RAII<\/a> idiom.  A lock automatically binds its mutex in the constructor and releases it in the destructor. This considerably reduces the risk of a deadlock because the runtime takes care of the mutex.<\/p>\n

Locks are available in two flavors in C++11. std::lock_guard<\/span> for the simple,  and std::unique-lock<\/span> for the advanced use case.<\/p>\n

std::lock_guard<\/a><\/span><\/h3>\n

First is the simple use case.<\/p>\n

<\/p>\n

\n
mutex m;\nm.lock();\nsharedVariable= getVar();\nm.unlock();\n<\/pre>\n<\/div>\n
 <\/p>\n
With so little code, mutex m<\/span> ensures access to the critical section sharedVariable= getVar()<\/span> is sequential. Sequential means  – in this particular case –  that each thread gains access to the critical section in order. The code is simple but prone to deadlocks. Deadlock appears if the critical section throws an exception or the programmer forgets to unlock the mutex. With std::lock_guard<\/span> we can do this more elegant:<\/p>\n
<\/p>\n
\n
{\n  std::mutex m,\n  std::lock_guard<std::mutex> lockGuard(m);\n  sharedVariable= getVar();\n}\n<\/pre>\n<\/div>\n
 <\/p>\n
That was easy. But what about the opening and closing brackets? The lifetime of std::lock_guard<\/span> is limited by the brackets (http:\/\/en.cppreference.com\/w\/cpp\/language\/scope#Block_scope<\/a>). That means its lifetime ends when it leaves the critical section. At that time, the destructor of std::lock_guard i<\/span>s called, and – I guess you know it – the mutex is released. It happens automatically, and, in addition, it happens if getVar()<\/span> in sharedVariable = getVar()<\/span> throws an exception. Of course, function body scope or loop scope also limits the lifetime of an object.<\/p>\n
std::unique_lock<\/a><\/span><\/h3>\n
std::unique_lock is mightier but more expansive than its small brother std::lock_guard<\/span>.<\/p>\n
A std::unique_lock <\/span>enables you<\/span>in addition to std::lock_guard <\/span><\/p>\n