Эффективный и современный С++. 42 рекомендации по использованию С++11 и С++14 - [46]

:

class Polynomial {
public:
 using RootsType =     // Структура данных, хранящая
  std::vector; // значения, где полином равен нулю
  …                    // (см. "using" в разделе 3.3)
 RootsType roots() const;

};

Вычисление корней — трудная дорогостоящая операция, так что мы не хотим их вычислять до того, как они реально потребуются. Но если они нам требуются, то, определенно, требуются не один раз. Поэтому мы будем кешировать корни полиномов, если нам приходится их вычислять, и реализуем roots так, чтобы функция возвращала кешированное значение. Вот как выглядит такой подход:

class Polynomial {
public:
 using RootsType = std::vector;

 RootsType roots() const {
  if (!rootsAreValid) { // Если кеш некорректен,
   …                    // вычисляем корни и сохраняем
                        // их в in rootVals
   rootsAreValid = true;
 }
 return rootVals;
}
private:
 mutable bool rootsAreValid{ false }; // См. инициализаторы
 mutable RootsType rootVals{};        // в разделе 3.1
};

Концептуально roots не изменяет объект Polynomial, с которым работает, но в качестве части кеширующих действий может потребоваться изменение rootVals и rootsAreValid. Это классический случай использования mutable, и именно поэтому эти данные-члены объявлены с данным модификатором.

Представим теперь, что два потока одновременно вызывают roots для объекта Polynomial:

Polynomial p;
…
/*----- Поток 1 ----- */     /*------- Поток 2 ------- */
auto rootsOfP = p.roots();   auto valsGivingZero = p.roots();

Этот клиентский код совершенно разумен. Функция roots является константной функцией-членом, и это означает, что она представляет операцию чтения. Выполнение операций чтения несколькими потоками одновременно без синхронизации вполне безопасно. Как минимум предполагается, что это так. В данном случае это не так, поскольку в функции roots один или оба эти потока могут попытаться изменить члены-данные rootsAreValid и rootVals. Это означает, что данный код может одновременно читать и записывать одни и те же ячейки памяти без синхронизации, а это — определение гонки данных. Такой код имеет неопределенное поведение.

Проблема заключается в том, что функция roots объявлена как const, но не является безопасной с точки зрения потоков. Объявление const является корректным как в С++11, так и в С++98 (вычисление корней полинома не изменяет сам полином), так что коррекция нужна для повышения безопасности потоков.

Простейший способ решения проблемы обычно один: применение mutex:

class Polynomial {
public:
 using RootsType = std::vector;
 RootsType roots() const {
  std::lock_guard g(m); // Блокировка мьютекса
  if (!rootsAreValid) {             // Если кеш некорректен
   …                                // Вычисление корней
   rootsAreValid = true;
 }
 return rootVals;
} // Разблокирование
private:
 mutable std::mutex m;
 mutable bool rootsAreValid{ false };
 mutable RootsType rootVals{};
};

Мьютекс std::mutex m объявлен как mutable, поскольку его блокировка и разблокирование являются неконстантными функциями, а в противном случае в константной функции-члене roots мьютекс m рассматривается как константный объект.

Следует отметить, что поскольку std::mutex не может быть ни скопирован, ни перемещен, побочным эффектом добавления m к Polynomial является то, что Polynomial теряет возможность копирования и перемещения.

В некоторых ситуациях мьютекс является излишеством. Например, если все, что вы делаете, — это подсчитываете, сколько раз вызывается функция-член, то часто более дешевым средством является счетчик std::atomic (т.e. счетчик, для которого гарантируется атомарность операций — см. раздел 7.6). (Действительно ли это более дешевое средство, зависит от аппаратного обеспечения и реализации мьютексов в вашей стандартной библиотеке.) Вот как можно использовать std::atomic для подсчета вызовов:

class Point { // Двумерная точка
public:
 …
 double distanceFromOrigin() // См. описание noexcept
 const noexcept              // в разделе 3.8
 {
  ++callCount;               // Атомарный инкремент
  return std::hypot(x, y);   // std::hypot - новинка C++11
 }
private:
 mutable std::atomic callCount{ 0 };
 double x, y;
};

Как и std::mutex, std::atomic невозможно копировать, так что наличие callCount в Point означает, что Point также невозможно копировать.

Поскольку операции над переменными std::atomic зачастую менее дорогостоящи, чем захват и освобождение мьютекса, вы можете соблазниться использовать std::atomic больше, чем следует. Например, в классе, кеширующем дорогостоящее для вычисления значение int, вы можете попытаться использовать вместо мьютекса пару переменных std::atomic:

class Widget {
public:
 …
 int magicValue() const {
  if (cacheValid) return cachedValue;
  else {
   auto val1 = expensiveComputation1();
   auto val2 = expensiveComputation2();
   cachedValue = val1 + val2; // Часть 1
   cachevalid = true;         // Часть 2
   return cachedValue;
  }
 }
private:
 mutable std::atomic cacheValid{ false };
 mutable std::atomic cachedValue;
};

Этот способ работает, но иногда выполняет существенно большую работу, чем требуется. Рассмотрим такой сценарий.