effective modern c++ 勉強会#3 item16

Effective Modern C++勉強会#3Item 16

刈谷満（@kariya_mitsuru）

2015/4/22

Item 16: Make const member functions thread safe.

const メンバ関数を

スレッドセーフにしよう


例

多項式を表すクラス

⇒Polynomial

その多項式の根を計算するメンバ関数

⇒roots

Item 16: Make const member functions thread safe.class Polynomial {

public:

using RootsType =

std::vector<double>;

RootsType roots() const;

…

};

多項式の根を計算するメンバ関数は、多項式自体を変更しない↓

const メンバ関数

根を保持するデータ構造(“using” については Item 9 を参照)


多項式の根の計算は高くつく。

⇓

必要なければ計算したくない。

でも 2 回以上は計算したくない。

⇓

最初に使われた時に計算しよう！

計算した根はキャッシュしよう！


public:

using RootsType = std::vector<double>;

RootsType roots() const {

if (!rootsAreValid) {

…

rootsAreValid = true;

}

return rootVals;

}

private:

bool rootsAreValid{ false };

RootsType rootVals{};

};


public:




…


}

return rootVals;

}

private:



};

キャッシュが有効じゃなかったら…


public:




…


}

return rootVals;

}

private:



};


根を計算してそれを rootVals に保存し…


public:




…


}

return rootVals;

}

private:



};



キャッシュを有効にする！


public:




…


}

return rootVals;

}

private:



};



キャッシュを有効にする！あれ？const メンバ関数じゃなかったっけ？


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 メンバ関数だから読むだけだし、同期しなくても大丈夫っしょ！！

死


public:




…


}

return rootVals;

}

private:



};

スレッド２スレッド１


public:




…


}

return rootVals;

}

private:



};


①rootsAreValidを読む⇓

まだ false


public:




…


}

return rootVals;

}

private:



};



まだ false

②rootsAreValidを読む⇓

まだ false！


public:




…


}

return rootVals;

}

private:



};



まだ false

③計算しては書き込む！（まだ false）


まだ false！


public:




…


}

return rootVals;

}

private:



};



まだ false



まだ false！

④計算しては書き込む！（まだ false）


public:




…


}

return rootVals;

}

private:



};



まだ false



まだ false！


データレース！


public:




…


}

return rootVals;

}

private:



};



まだ false



まだ false！


データレース！ようこそＵＢへ！


ここでの問題は…

roots は const メンバ関数なのに、スレッドセーフじゃない。

⇓

const メンバ関数であることは C++11 でも C++98 でも正しい。

（rootsは多項式の値を変更しない）

⇓

直すべきはスレッドセーフ性の欠如


解決策

mutex を使え


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 を使う方がいんじゃね？

⇓

ちょっと書いてみました


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 より軽いかどうかは、動作するハードウェアと標準ライブラリの実装によるので注意！）

Item 16: Make const member functions thread safe.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 参照）

Item 16: Make const member functions thread safe.class Point {

public:

…

double distanceFromOrigin() const noexcept

{

++callCount;


}

private:


double x, y;

};

例によって、std::atomic<T> もコピーはおろかムーブも出来ないので注意！（本書Errata）

Item 16: Make const member functions thread safe.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();auto val2 = expensiveComputation2();cachedValue = val1 + val2;cacheValid = true;return cachedValue;

}}

private:mutable std::atomic<bool> cacheValid{ false };mutable std::atomic<int> cachedValue;

};

キャッシュする値とその有効フラグを

atomic にしました！





}}


};

キャッシュする値とその有効フラグを

atomic にしました！

ホントに大丈夫…？





}}


};






}}


};


①有効か確認する⇓

まだ無効





}}


};


②計算して格納（まだ無効）


まだ無効





}}


};



③有効か確認する⇓

まだ無効


まだ無効





}}


};




まだ無効


まだ無効

④計算して格納（まだ無効）





}}


};




まだ無効


まだ無効

④計算して格納（まだ無効）残念！！！


class Widget {

public:

…

int magicValue() const {

if (cacheValid) return cachedValue;

else {

auto val1 = expensiveComputation1();


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;


}

}

…

};




まだ無効


class Widget {

public:

…



else {



cacheValid = true;


}

}

…

};



③有効にする！（まだ格納前！）


まだ無効


class Widget {

public:

…



else {



cacheValid = true;


}

}

…

};




④有効か確認する⇓

有効！？値を返す！！！


まだ無効


class Widget {

public:

…



else {



cacheValid = true;


}

}

…

};




④有効か確認する⇓

有効！？値を返す！！！


まだ無効

死


教訓

単一の変数やメモリ位置の同期が必要

⇒ std::atomic

2 つ以上の変数やメモリ位置に対して不可分操作が必要

⇒ mutex（std::atomic じゃＮＧ！）

Item 16: Make const member functions thread safe.class Widget {public:…int magicValue() const {std::lock_guard<std::mutex> guard(m);if (cacheValid) return cachedValue;else {


}}…

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

Technology