More Related Content Similar to 規格書で読むC++11のスレッド Similar to 規格書で読むC++11のスレッド (20) More from Kohsuke Yuasa (10) 2. 発表者自己紹介
✤ @hotwatermorning
✤ DTMer
✤ C++ポケットリファレンス書きました！（共著）
✤ Amazonのなか見検索に対応！
2
http://www.amazon.co.jp/C-%E3%83%9D
%E3%82%B1%E3%83%83%E3%83%88%E3%83%AA
%E3%83%95%E3%82%A1%E3%83%AC%E3%83%B3%E3%82%B9-
%E9%AB%98%E6%A9%8B-%E6%99%B6/dp/4774157155
5. Free Lunch Is Over
5
✤ タダ飯の時代は終わった
✤ 2005年
マイクロソフトの Software Architect である
Herb Sutterの言葉
✤ CPUコアのクロック数向上が頭打ちとなり、時
を待てば自ずとソフトウェアの性能が上がるとい
う時代の終わり
✤ →並行プログラミングが重要に
7. #include <iostream>
#include <thread>
#include <vector>
#include <functional>
int main() {
std::vector<int> data = GetSomeData();
int sum;
std::thread th(
[](std::vector<int> const &data_, int &sum_) {
sum_ = 0;
for(auto n : data_) { sum_ += n; }
},
std::cref(data), std::ref(sum) );
th.join();
std::cout << "sum of data is : " << sum << std::endl;
}
C++のスレッド
7
16. thread
✤ スレッドを扱うクラス ( 30.3.1)
✤ threadクラスは新たな実行スレッドを作成したり、その
スレッドの終了を待機したり、その他スレッドの状態を問
い合せる操作のメカニズムを提供します。
✤ スレッドの作成やスレッドハンドルの管理を行う
✤ そのためプログラマが常に明示的にスレッドの作成や
ハンドルの管理を意識する必要がない
✤ Not Copyable / Movable
16
19. template <class F, class ...Args>
explicit thread(F&& f, Args&&... args);
// というコンストラクタについて、
INVOKE (
DECAY_COPY(
std::forward<F>(f)
),
DECAY_COPY(
std::forward<Args>(args)
)...
)
// が有効であるような関数や引数を渡せる
コンストラクタの定義
19
22. // INVOKEが表す仮想的な呼び出し操作は
INVOKE(f, t1, t2, ..., tN);
// 実際には以下から適切なものが呼び出される
(t1.*f)(t2, ..., tN);
((*t1).*f)(t2, ..., tN);
f(t1, t2, ..., tN);
INVOKE()
22
23. struct Foo {
// operator()をもつクラス
// → 関数オブジェクト（別名：ファンクタ）
void operator() (std::string msg) const {
std::cout << "Hello " << msg << std::endl;
}
};
Foo foo;
std::string msg = "World!";
foo("World"); // Hello World!
//関数のように呼び出せる
INVOKE()
23
24. int main() {
std::string msg = "World!";
Foo foo;
// 関数のように呼び出せるものは
// スレッドに渡せる
std::thread th(foo, msg); // Hello World!
//スレッドの終了を待機
th.join();
}
INVOKE()
24
26. #include <thread>
#include <iostream>
#include <functional>
void add(int a, int b, int &c) {
c = a + b;
}
int main() {
int result;
std::thread th1(add, 1, 2, std::ref(result));
th1.join();
std::cout << result << std::endl;
}
スレッドに参照を渡す
26
27. thread
✤ スレッドを扱うクラス ( 30.3.1)
✤ threadクラスは新たな実行スレッドを作成したり、その
スレッドの終了を待機したり、その他スレッドの状態を問
い合せる操作のメカニズムを提供します。
✤ スレッドの作成やスレッドハンドルの管理を行う
✤ そのためプログラマが常に明示的にスレッドの作成や
ハンドルの管理を意識する必要がない
✤ Not Copyable / Movable
27
30. Movable Type
✤ MoveConstructible要件 と
MoveAssignable要件 を満たす型 ( 17.6.3.1)
✤ データ（の所有権）を移動して、オブジェクト間
でデータを受け渡せる
✤ （Movable自体はC++規格に定義された用語で
はないが、上の2つの性質をまとめてMovableと
いう）
30
31. // MoveConstructible
T u = SomeFunctionReturnsT();
T(SomeFunctionReturnsT());
// MoveAssignable
u = SomeFunctionReturnsT();
Movable Type
31
33. #include <cassert>
#include <thread>
#include <iostream>
void foo(int a, int b) { std::cout << a << ", " << b << std::endl; }
int main() {
std::thread th1(foo, 1, 2);
// コンパイルエラー
std::thread th2 = th1;
// ムーブなら問題ない
std::thread th3 = std::move(th1);
// ムーブ元のth1はスレッドを手放している。
assert(th1.get_id() == std::thread().get_id());
th3.join();
}
スレッドの受け渡し
33
37. void worker(SomeParam p)
{
doSomething();
}
void foo(SomeParam p)
{
std::thread th(worker, p);
// このまま関数を抜ける
// →std::terminate()で強制終了
}
デストラクタとjoin/detach
37
52. #include <chrono>
SomeTimedLockableType m;
// 指定時間だけ所有権の取得を試行
m.try_lock_for(
std::chrono::seconds(3)
);
// 指定時刻まで所有権の取得を試行
m.try_lock_until(
std::chrono::steady_clock()::now() +
std::chrono::seconds(3)
);
Lockable Type
52
59. struct Worker {
//...
void process() {
for(int i = 0; i < 100; ++i) {
//このスコープ内だけ排他処理する
std::lock_guard<std::mutex> lock(mutex_);
data_ = doSomething(data_);
}
}
private:
std::mutex mutex_;
int data_;
// ...
};
std::lock_guard<Mutex>
59
66. void sum_async( std::vector<int> const &data,
std::promise<int> promise) {
int sum = 0;
for(auto n : data) { sum += n; }
promise.set_value(sum); // promiseにデータをセットし
}
int main() {
std::vector<int> data = { 1, 2, 3 };
std::promise<int> p;
std::future<int> f = p.get_future();
std::thread th(
sum_async, std::cref(data), std::move(p));
th.detach();
std::cout << f.get() << std::endl; // futureで受け取る
}
future/promise
66
69. void sum_async( std::vector<int> const &data,
std::promise<int> promise) {
if(data.empty()) {
std::exception_ptr pe =
std::make_exception_ptr(
UnexpectedDataLengthError() );
// エラーを表すときは、promiseに例外をセットする
promise.set_exception(pe);
} else {
int sum = 0;
for(auto n : data) { sum += n; }
promise.set_value(sum);
}
}
例外の受け渡し（セット側）
69
70. int main() {
std::vector<int> data = {};
std::promise<int> p;
std::future<int> f = p.get_future();
std::thread th(
sum_async, std::cref(data), std::move(p));
th.detach();
try {
std::cout << f.get() << std::endl;
// futureのget()で例外が再送出される
} catch(UnexpectedDataLengthError &e) {
std::cout << e.what() << std::endl;
}
}
例外の受け渡し（取得側）
70
74. std::condition_variable cond;
std::mutex mutex;
bool data_ready;
void process_data();
void wait_for_data_to_process() {
std::unique_lock<std::mutex> lock(mut);
// データが準備できるまで待機する。
while(!data_ready) {
cond.wait(lock);
}
process_data();
}
condition_variable
74
75. void retrieve_data();
void prepare_data();
void prepare_data_for_processing() {
retrieve_data();
prepare_data();
{
boost::lock_guard<boost::mutex> lock(mut);
data_ready=true;
}
// データが準備できたら待機状態のスレッドを起こす
cond.notify_one();
}
condition_variable
75
86. //! タスクの実体クラス
//! Boost.Preprocessorを用いて、10引数を取るタスクまでをサポート
template<class F BOOST_PP_ENUM_TRAILING(11, HWM_TASK_template_parameters, unused)>
struct task_impl;
#define BOOST_PP_LOCAL_MACRO(iteration_value)
template<class F BOOST_PP_ENUM_TRAILING(iteration_value, HWM_TASK_template_parameters_specialized, unused)>
struct task_impl<F BOOST_PP_ENUM_TRAILING_PARAMS(iteration_value, Arg) /*BOOST_PP_ENUM_TRAILING(BOOST_PP_SUB(10,
iteration_value), HWM_TASK_default_params, unused) */>
: task_base
{
typedef typename function_result_type<F BOOST_PP_ENUM_TRAILING_PARAMS(iteration_value, Arg)>::type result_type;
typedef std::promise<result_type> promise_type;
task_impl(promise_type && promise, F && f BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(iteration_value, Arg, &&arg))
: promise_(boost::move(promise))
, f_(std::forward<F>(f))
BOOST_PP_ENUM_TRAILING(iteration_value, HWM_TASK_initialize_member_variables, unused)
{}
private:
task_impl(task_impl const &) = delete;
task_impl & operator=(task_impl const &) = delete;
promise_type promise_;
F f_;
BOOST_PP_REPEAT(iteration_value, HWM_TASK_define_member_variables, unused)
virtual
void run() override final
{
try {
promise_.set_value(f_(BOOST_PP_ENUM(iteration_value, HWM_TASK_apply_member_variables, unused)));
} catch(...) {
promise_.set_exception(std::current_exception());
}
}
};
/**/
task_impl
86
87. //! タスクの実体クラス
//! Boost.Preprocessorを用いて、10引数を取るタスクまでをサポート
template<class F>
struct task_impl {
task_imp(std::promise<F()の戻り値> &&promise, F &&f)
: promise_(std::move(promise))
, f_(std::forward<F>(f))
{}
std::promise<F()の戻り値> promise_;
F f_;
void run() override final {
try {
promise_.set_value(f_());
} catch(...) {
promise_.set_exception(std::current_exception());
}
}
};
task_impl
87
88. //! タスクの実体クラス
//! Boost.Preprocessorを用いて、10引数を取るタスクまでをサポート
template<class F, class Arg0>
struct task_impl {
task_imp(std::promise<F()の戻り値> &&promise, F &&f, Arg0 &&arg0)
: promise_(std::move(promise))
, f_(std::forward<F>(f))
, arg0_(arg0)
{}
std::promise<F()の戻り値> promise_;
F f_;
Arg0 arg0_;
void run() override final {
try {
promise_.set_value(f_(std::forward<Arg0>(arg0_)));
} catch(...) {
promise_.set_exception(std::current_exception());
}
}
};
task_impl
88
90. namespace hwm {
struct task_queue {
// タスクをキューに追加する
template<class F, class... Args>
std::future<F(Args)の戻り値の型>
>
enqueue_sync(F f, Args... args);
//...
};
}
タスクの追加
90
