A lock guard is a simple mutex wrapper, which handles the obtaining of a lock on the mutex object as well as its release when the lock guard goes out of scope. This is a helpful mechanism to ensure that one does not forget to release a mutex lock, and to help reduce clutter in one's code when one has to release the same mutex in multiple locations.

While refactoring of, for example, big if/else blocks can reduce the instances in which the release of a mutex lock is required, it's much easier to just use this lock guard wrapper and not worry about such details:

#include <thread> 
#include <mutex> 
#include <iostream> 
  
int counter = 0; 
std::mutex counter_mutex; 
  
void worker() { 
         std::lock_guard<std::mutex> lock(counter_mutex); 
   if (counter == 1) { counter += 10; } 
   else if (counter >= 10) { counter += 15; } 
   else if (counter >= 50) { return; } 
         else { ++counter; } 
  
   std::cout << std::this_thread::get_id() << ": " << counter << 'n'; 
} 
  
int main() { 
    std::cout << __func__ << ": " << counter << 'n'; 
  
    std::thread t1(worker); 
    std::thread t2(worker); 
  
    t1.join(); 
    t2.join(); 
  
    std::cout << __func__ << ": " << counter << 'n'; 
} 

In the preceding example, we see that we have a small if/else block with one condition leading to the worker function immediately returning. Without a lock guard, we would have to make sure that we also unlocked the mutex in this condition before returning from the function.

With the lock guard, however, we do not have to worry about such details, which allows us to focus on the business logic instead of worrying about mutex management.