Effective Modern C++ 勉強会#3 Item16

Effective Modern C++
勉強会#3
Item 16
刈谷満（@kariya_mitsuru）
2015/4/22

Item 16: Make const member functions thread safe.
const メンバ関数を
スレッドセーフにしよう

例
多項式を表すクラス
⇒Polynomial
その多項式の根を計算するメンバ関数
⇒roots

class Polynomial {
public:
using RootsType =
std::vector<double>;
RootsType roots() const;
…
};
多項式の根を計算するメンバ関数は、多項式自体を変更しない
↓
const メンバ関数
根を保持するデータ構造
(“using” については Item 9 を参照)

多項式の根の計算は高くつく。
⇓
必要なければ計算したくない。
でも 2 回以上は計算したくない。
⇓
最初に使われた時に計算しよう！
計算した根はキャッシュしよう！

class Polynomial {
public:
using RootsType = std::vector<double>;
RootsType roots() const {
if (!rootsAreValid) {
…
rootsAreValid = true;
}
return rootVals;
}
private:
bool rootsAreValid{ false };
RootsType rootVals{};
};

class Polynomial {
public:
…
}
return rootVals;
}
private:
};
キャッシュが有効じゃなかったら…

class Polynomial {
public:
…
}
return rootVals;
}
private:
};
根を計算してそれを rootVals に保存し…

class Polynomial {
public:
…
}
return rootVals;
}
private:
};
キャッシュを有効にする！

class Polynomial {
public:
…
}
return rootVals;
}
private:
};
キャッシュを有効にする！
あれ？
const メンバ関数じゃなかったっけ？

class Polynomial {
public:
…
}
return rootVals;
}
private:
mutable bool rootsAreValid{ false };
mutable RootsType rootVals{};
};
mutable！
roots は概念的にはオブジェクトを変更しない（論理的 const 性）
詳しくはWebで！！
Effective C++ 第3版、Item 3 参照

ところで、この Polynomial クラスのオブジェクトを複数スレッドで同時に使うと…
Polynomial p;
…
スレッド２
auto valsGivingZero = p.roots();
スレッド１
auto rootsOfP = p.roots();
const メンバ関数だから読むだけだし、
同期しなくても大丈夫っしょ！！

ところで、この Polynomial クラスのオブジェクトを複数スレッドで同時に使うと…
Polynomial p;
…
スレッド２
auto valsGivingZero = p.roots();
スレッド１
auto rootsOfP = p.roots();
const メンバ関数だから読むだけだし、
同期しなくても大丈夫っしょ！！
死

class Polynomial {
public:
…
}
return rootVals;
}
private:
};
スレッド２スレッド１

class Polynomial {
public:
…
}
return rootVals;
}
private:
};
①rootsAreValid を読む
⇓
まだ false

class Polynomial {
public:
…
}
return rootVals;
}
private:
};
⇓
まだ false
②rootsAreValid を読む
⇓
まだ false！

class Polynomial {
public:
…
}
return rootVals;
}
private:
};
⇓
まだ false
③計算しては書き込む！
（まだ false）
⇓
まだ false！

class Polynomial {
public:
…
}
return rootVals;
}
private:
};
⇓
まだ false
（まだ false）
⇓
まだ false！
④計算しては書き込む！
（まだ false）

class Polynomial {
public:
…
}
return rootVals;
}
private:
};
⇓
まだ false
（まだ false）
⇓
まだ false！
（まだ false）
データレース！

class Polynomial {
public:
…
}
return rootVals;
}
private:
};
⇓
まだ false
（まだ false）
⇓
まだ false！
（まだ false）
データレース！ようこそＵＢへ！

ここでの問題は…
roots は const メンバ関数なのに、スレッドセーフじゃない。
⇓
const メンバ関数であることは C++11 でも C++98 でも正しい。
（rootsは多項式の値を変更しない）
⇓
直すべきはスレッドセーフ性の欠如

解決策
mutex を使え

class Polynomial {
public:
std::lock_guard<std::mutex> g(m);
ここは前と一緒…
return rootVals;
}
private:
mutable std::mutex m;
ここも前と一緒…
};
lock_guard を使って
m をロック！
ブロックの終わりで
m をアンロック！
ここの mutable にも注意！
ロック、アンロックは const メンバ関数じゃない
でも、m が変わっても多項式はやっぱり変わらない！

Caution!(Errataあり)
std::mutex はコピーもムーブもできない。
Polynomial に m を追加した結果、
コピーもムーブも出来なくなった。

Caution!(Errataあり)
std::mutex はコピーもムーブもできない。
Polynomial に m を追加した結果、
コピーもムーブも出来なくなった。
独自のコピー、ムーブコンストラ
クタ、代入演算子を定義すれば
いいと思うんだけど…

コメントあり
もし Polynomial が変更不可だったら、std::call_once と
std::once_flag を使う方がいんじゃね？
⇓
ちょっと書いてみました

class Polynomial {
public:
std::call_once(flag, [this]{ calc(); });
return rootVals;
}
void calc() const {
…
}
private:
mutable std::once_flag flag{};
};
call_once を使って
calc を一回だけ呼ぶ
(λ をつかってる理由は
Item 34 参照）
実際に計算、格納するメンバ関数
もちろん const メンバ関数
もちろん once_flag も mutable！

場合によっては mutex は重過ぎ
例）メンバ関数が呼ばれた回数を数えたい
⇓
std::atomic で十分
（実際に std::atomic の方が mutex より軽いかどうかは、
動作するハードウェアと標準ライブラリの実装によるので注意！）

class Point {
public:
…
double distanceFromOrigin() const noexcept
{
++callCount;
return std::hypot(x, y);
}
private:
mutable std::atomic<unsigned> callCount{ 0 };
double x, y;
};
アトミック（不可分）なインクリメント
（Item 40 参照）

class Point {
public:
…
double distanceFromOrigin() const noexcept
{
++callCount;
}
private:
double x, y;
};
例によって、std::atomic<T> も
コピーはおろかムーブも
出来ないので注意！
（本書Errata）

class Point { // 二次元の点
public:
…
double distanceFromOrigin() const noexcept // noexcept については
{
++callCount;
}
private:
double x, y;
};
あ、あと、std::hypotも
わりとデキる奴なので
忘れないであげてください！（＞＜）
（本書Errata）
hypotenuse squared

でも…
mutex より std::atomic の方が軽いからと言って、
使いすぎは禁物！
例）重い計算結果のキャッシュ（int）と
キャッシュの有効フラグ（bool）

class Widget {
public:
…
int magicValue() const {
if (cacheValid) return cachedValue;
else {
auto val1 = expensiveComputation1();
cachedValue = val1 + val2;
cacheValid = true;
return cachedValue;
}
}
private:
mutable std::atomic<bool> cacheValid{ false };
mutable std::atomic<int> cachedValue;
};
キャッシュする値と
その有効フラグを
atomic にしました！

class Widget {
public:
…
else {
cacheValid = true;
return cachedValue;
}
}
private:
};
キャッシュする値と
その有効フラグを
atomic にしました！
ホントに
大丈夫…？

class Widget {
public:
…
else {
cacheValid = true;
return cachedValue;
}
}
private:
};

class Widget {
public:
…
else {
cacheValid = true;
return cachedValue;
}
}
private:
};
①有効か確認する
⇓
まだ無効

class Widget {
public:
…
else {
cacheValid = true;
return cachedValue;
}
}
private:
};
②計算して格納
（まだ無効）
⇓
まだ無効

class Widget {
public:
…
else {
cacheValid = true;
return cachedValue;
}
}
private:
};
（まだ無効）
③有効か確認する
⇓
まだ無効
⇓
まだ無効

class Widget {
public:
…
else {
cacheValid = true;
return cachedValue;
}
}
private:
};
（まだ無効）
⇓
まだ無効
⇓
まだ無効
④計算して格納
（まだ無効）

class Widget {
public:
…
else {
cacheValid = true;
return cachedValue;
}
}
private:
};
（まだ無効）
⇓
まだ無効
⇓
まだ無効
④計算して格納
（まだ無効）残念！！！

class Widget {
public:
…
else {
cacheValid = true;
return cachedValue = val1 + val2;
}
}
…
};
じゃあじゃあ、
キャッシュの有効化と
値の代入を逆にしよう！

class Widget {
public:
…
else {
cacheValid = true;
}
}
…
};
じゃあじゃあ、
キャッシュの有効化と
値の代入を逆にしよう！
ホントにホントに
大丈夫…？

class Widget {
public:
…
else {
cacheValid = true;
}
}
…
};

class Widget {
public:
…
else {
cacheValid = true;
}
}
…
};
⇓
まだ無効

class Widget {
public:
…
else {
cacheValid = true;
}
}
…
};
②２つとも計算する
（まだ無効）
⇓
まだ無効

class Widget {
public:
…
else {
cacheValid = true;
}
}
…
};
（まだ無効）
⇓
まだ無効
⇓
まだ無効

class Widget {
public:
…
else {
cacheValid = true;
}
}
…
};
（まだ無効）
⇓
まだ無効
⇓
まだ無効
④２つとも計算する
（まだ無効）

class Widget {
public:
…
else {
cacheValid = true;
}
}
…
};
（まだ無効）
⇓
まだ無効
⇓
まだ無効
④２つとも計算する
（まだ無効）
残念！！！
(本書Ｅｒｒａｔａ)

でも…
実はもっとヤバい…

class Widget {
public:
…
else {
cacheValid = true;
}
}
…
};
（まだ無効）
③有効にする！
（まだ格納前！）
⇓
まだ無効

class Widget {
public:
…
else {
cacheValid = true;
}
}
…
};
（まだ無効）
④有効か確認する
⇓
有効！？
値を返す！！！
⇓
まだ無効

class Widget {
public:
…
else {
cacheValid = true;
}
}
…
};
（まだ無効）
④有効か確認する
⇓
有効！？
値を返す！！！
⇓
まだ無効
死

教訓
単一の変数やメモリ位置の同期が必要
⇒ std::atomic
2 つ以上の変数やメモリ位置に対して不可分操作が必要
⇒ mutex（std::atomic じゃＮＧ！）

class Widget {
public:
…
std::lock_guard<std::mutex> guard(m);
else {
cacheValid = true;
return cachedValue;
}
}
…
private:
mutable std::mutex m;
mutable int cachedValue;
mutable bool cacheValid{ false };
};
lock_guard を使って
m をロック！
ブロックの終わりで
m をアンロック！
例によって mutable！
もはや atomic の必要なし！

ところで…
散々マルチスレッドの話をしてきたけど、
シングルスレッド前提の場合は？
⇓
これらの対応は不要
（その場合、mutex や std::atomic に
関するコストを避けられる）

覚えておくこと
• 並行コンテキストで決して使用しないと確信できない限り、
const メンバ関数をスレッドセーフにしておくこと。
• std::atomic の使用は mutex よりも良いパフォーマンスを示す
かもしれないが、それは単一の変数やメモリ位置への操作のみに適
している。

Effective Modern C++ 勉強会#3 Item16

More Related Content

What's hot (20)

Viewers also liked (15)

Similar to Effective Modern C++ 勉強会#3 Item16 (20)

Recently uploaded (11)

Effective Modern C++ 勉強会#3 Item16