![\"DealingWithMutation\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2023\/05\/DealingWithMutation.png\")
<\/p>\nLocking is a classical way to protect a shared, mutable state. Today, I will present the two variants, Scoped Locking and Strategized Locking.<\/p>\n
<\/p>\n
<\/p>\n
Locking is a straightforward idea to protect a critical section. A critical section is a section of code that, at most, one thread can use at any time.<\/p>\n
Scoped locking is the idea of The class <\/p>\n <\/p>\n The scope of Scoped locking has the following advantages and disadvantages.<\/p>\n C++17 supports locks in four variations. C++ has a Strategized Locking often applies Scoped Locking.<\/p>\n<\/p>\nRAII<\/code> <\/a>applied to a mutex<\/a>. Scoped locking is also known as synchronized block and guard. The key idea of this idiom is to bind the resource acquisition and release to an object\u2019s lifetime. As the name suggests, the lifetime of the object is scoped. Scoped means that the C++ run time is responsible for object destruction and, therefore, for releasing the resource.<\/p>\nScopedLock<\/code> implements Scoped Locking.<\/p>\n\n\/\/ scopedLock.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <mutex><\/span>\r\n#include <new><\/span>\r\n#include <string><\/span>\r\n\r\nclass<\/span> ScopedLock<\/span>{\r\n private:<\/span>\r\n std::<\/span>mutex&<\/span> mut;\r\n public:<\/span>\r\n explicit<\/span> ScopedLock<\/span>(std::<\/span>mutex&<\/span> m):<\/span> mut(m){ \/\/ (1)<\/span><\/em>\r\n\t\tmut.lock(); \/\/ (2)<\/span><\/em>\r\n\t\tstd::<\/span>cout <<<\/span> \"Lock the mutex: \"<\/span> <<<\/span> &<\/span>mut <<<\/span> '\\n'<\/span>; \r\n }\r\n ~<\/span>ScopedLock(){\r\n\t\tstd::<\/span>cout <<<\/span> \"Release the mutex: \"<\/span> <<<\/span> &<\/span>mut <<<\/span> '\\n'<\/span>; \r\n\t\tmut.unlock(); \/\/ (3)<\/span><\/em>\r\n }\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n std::<\/span>mutex mutex1;\r\n ScopedLock scopedLock1{mutex1};\r\n\r\n std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>Before local scope\"<\/span> <<<\/span> '\\n'<\/span>;\r\n {\r\n std::<\/span>mutex mutex2;\r\n ScopedLock scopedLock2{mutex2};\r\n } \/\/ (4)<\/span><\/em>\r\n std::<\/span>cout <<<\/span> \"After local scope\"<\/span> <<<\/span> '\\n'<\/span>;\r\n \r\n std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>Before try-catch block\"<\/span> <<<\/span> '\\n'<\/span>;\r\n try{\r\n std::<\/span>mutex mutex3;\r\n ScopedLock scopedLock3{mutex3};\r\n throw<\/span> std::<\/span>bad_alloc();\r\n } \/\/ (5)<\/span><\/em>\r\n catch<\/span> (std::<\/span>bad_alloc&<\/span> e){\r\n std::<\/span>cout <<<\/span> e.what();\r\n }\r\n std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>After try-catch block\"<\/span> <<<\/span> '\\n'<\/span>;\r\n \r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n \r\n}\r\n<\/pre>\n<\/div>\nScopedLock<\/code> gets its mutex by reference (line 1). The mutex is locked in the constructor (line 2) and unlocked in the destructor (line 3). Thanks to the RAII idiom, the object\u2019s destruction and, therefore, the unlocking of the mutex is done automatically.<\/p>\nscopedLock1<\/code> ends at the end of the main function. Consequentially, mutex1<\/code> is unlocked. The same holds for mutex2<\/code> and mutex3<\/code>. They are automatically unlocked at the end of their local scopes (lines 4 and 5). For mutex3<\/code>, the destructor of the scopedLock3<\/code> is also invoked if an exception occurs. Interestingly, mutex3<\/code> reuses the memory of mutex2<\/code> because both have the same address.<\/p>\n![\"scopedLock\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2023\/05\/scopedLock.png\")
<\/p>\n\n
\n
\n
std::mutex<\/code> is undefined behavior and may typically cause a deadlock<\/li>\nlongjmp<\/code> <\/a>is used; longjpm<\/code> does not call C++ destructors of scoped objects<\/li>\n<\/ul>\n<\/li>\n<\/ul>\nstd::lock_guard \/ std::scoped_lock<\/code> for the simple and a std::unique_lock \/ std::shared_lock<\/code> for the advanced use cases such as explicit locking or unlocking of the mutex. You can read more about mutex and locks in my previous post, “Prefer Locks to Mutexes<\/a>“.<\/p>\nStrategized Locking<\/h2>\n