Cpp Concurrency In Action(読書ノート1)——スレッド入門と管理

12630 ワード

前言:
本書原文:クリックしてリンクを開く
読書ノートのコードはすべてVS 2015(Windows)で実行されます.
スレッドの開始

#include <iostream>
#include <thread> //1
void hello() //2
{
	std::cout << "Hello Concurrent World
";
}
int main()
{
	std::thread t(hello); //3：        ，    
	t.join(); //4：       t     
	system("pause");
	return 0;
}

スレッドの開始

#include <iostream>
#include <thread>
void do_something()
{
	std::cout << "do_something()" << std::endl;
}
void do_something_else()
{
	std::cout << "do_something_else()" << std::endl;
}
class background_task
{
public:
	void operator()() const
	{
		do_something();
		do_something_else();
	}
};
void hello()
{
	std::cout << "Hello Concurrent World
";
}
int main()
{
	std::thread t(hello); 
	t.join(); //    ，   
	//    
	background_task f;
	std::thread my_thread1(f);
	my_thread1.join();

	//      ：           

	//std::thread my_thread(background_task());
	/*  ，       my_thread   ，
	*          (             background_task     )，
	*     std::thread      ，         。
	*/

	std::thread my_thread2((background_task()));//      
	my_thread2.join();

	std::thread my_thread3{ background_task() };//        
	my_thread3.join();

	//  lambda   
	std::thread my_thread4([] {
		do_something();
		do_something_else();
	});
//	my_thread4.join();//        join()，   
	system("pause");
	return 0;
}

関数は終了し、スレッドはローカル変数にアクセスします.

#include <iostream>
#include <thread>
void do_something(unsigned i)
{
	std::cout << "do_something("<<i<<")" << std::endl;
}
struct func
{
	int& i;
	func(int& i_) : i(i_) {}
	void operator() ()
	{
		for (unsigned j = 0; j<1000000; ++j)
		{
			do_something(i); // 1.       ：    
		}
	}
};
void oops()
{
	int some_local_state = 0;
	func my_func(some_local_state);
	std::thread my_thread(my_func);
	//my_thread.detach(); // 2.        ，     i    
	my_thread.join();//      ，  i=0
} // 3.          
int main()
{
	oops();
	system("pause");
	return 0;
}

join()は、単純で乱暴なスレッドの完了を待つか、待たないかである.待機中のスレッドをより柔軟に制御する必要がある場合は、たとえば、スレッドが終了しているかどうかを確認したり、しばらく待つだけ(時間を超えるとタイムアウトと判定されます).これを行うには、条件変数や期待(futures)などの他のメカニズムを使用する必要があります.関連する議論は4章で続きます.join()の動作を呼び出し、std::threadオブジェクトが完了したスレッドに関連付けられなくなるように、スレッド関連のストレージ部分もクリーンアップします.これは、1つのスレッドに対して1回しかjoin()を使用できないことを意味する.join()が既に使用されている場合、std::threadオブジェクトは再び追加できません.joinable()を使用すると、No(false)が返されます.
スレッド完了待ち

void f()
{
	int some_local_state = 0;
	func my_func(some_local_state);
	std::thread t(my_func);
	try
	{
		do_something_else();
	}
	catch (...)
	{
		t.join(); // 1
		throw;
	}
	t.join(); // 2
}

RAIDを使用してスレッドの完了を待つ

#include <iostream>
#include <thread>
void do_something(unsigned i)
{
	std::cout << "do_something("<<i<<")" << std::endl;
}
void do_something_else()
{

}
struct func
{
	int& i;
	func(int& i_) : i(i_) {}
	void operator() ()
	{
		for (unsigned j = 0; j<10; ++j)
		{
			do_something(i); // 1.       ：    
		}
	}
};
class thread_guard
{
	std::thread& t;
public:
	//           
	explicit thread_guard(std::thread& t_) 
		:t(t_)
	{}
	~thread_guard()
	{
		if (t.joinable()) // 1
		{
			t.join(); // 2
		}
	}
	thread_guard(thread_guard const&) = delete; // 3
	thread_guard& operator=(thread_guard const&) = delete;
};
void f()
{
	int some_local_state = 0;
	func my_func(some_local_state);
	std::thread t(my_func);
	thread_guard g(t);//        ，RAII（          ）
	do_something_else();
} // 4
int main()
{
	f();
	system("pause");
	return 0;
}

バックグラウンド実行スレッド

#include <iostream>
#include <thread>
#include <cassert>
void f()
{
	int some_local_state = 0;
	func my_func(some_local_state);
	std::thread t(my_func);
	t.detach();
	assert(!t.joinable());//     
	//            ,             ！
}

パラメータをスレッド関数に渡す
スレッド関数としてメンバー関数ポインタを渡し、最初のパラメータとして適切なオブジェクトポインタを指定します.

class X
{
public:
	void do_lengthy_work();
};
X my_x;
std::thread t(&X::do_lengthy_work, &my_x); // 1

新しいスレッドはmy_x.do_lengthy_work()はスレッド関数として;my_xのアドレス①はポインタオブジェクトとして関数に与えられる.メンバー関数にパラメータ:std::threadコンストラクション関数の3番目のパラメータがメンバー関数の最初のパラメータであることもできます.

class X
{
public:
	void do_lengthy_work(int);
};
X my_x;
int num(0);
std::thread t(&X::do_lengthy_work, &my_x, num);

一般関数パラメータの伝達

#include <iostream>
#include <thread>
#include <string>
void f(int i, std::string const& s)
{
	std::cout  << i << "\t" <<s<< std::endl;
}
void oops(int some_param)
{
	char buffer[1024]; 
	sprintf_s(buffer, "%i", some_param);//%i=%d----%u
	std::thread t1(f, 2, buffer);
	//                std::string       ，            。
	t1.join();
	std::thread t2(f, 3, std::string(buffer)); 
	/*                     std::string   ，
	*   std::thread              ，
	*                     。
	*/
	t2.detach();
}
int main()
{
	std::thread t(f, 1, "hello");
	oops(512111);
	system("pause");
	return 0;
}

参照の転送

#include <iostream>
#include <thread>
#include <string>
void f(const std::string &s,int &i)
{
	std::cout  << i <<s<< std::endl;
	++i;
}
int main()
{
	int a = 1;
//	std::thread t(f, "hello",a);
	/*  ，             ，   std::thread          ；
	*               ，            。
	*     f   ，         a         ，         。
	*  ，      ，                  ，
	*    a          。
	*/
	std::thread t(f,"hello",std::ref( a));
	t.join();
	f("world",a);
	std::cout << a << std::endl;
	system("pause");
	return 0;
}

std::move

#include <iostream>
#include <thread>
#include <memory>
class big_object {
public:
	void prepare_data(int _a)
	{
		a = _a;
	}
	int a;
};
void process_big_object(std::unique_ptr<big_object> p)
{
	std::cout << p->a << std::endl;
}
int main()
{
	std::unique_ptr<big_object> p(new big_object);
	p->prepare_data(42);
	std::thread t(process_big_object, std::move(p));//p    ，    
	t.join();
	system("pause");
	return 0;
}

で提供されるパラメータは「移動」(move)できますが、「コピー」(copy)できません.「移動」とは、元のオブジェクトのデータが別のオブジェクトに転送され、転送されたデータが元のオブジェクトに保存されなくなることを意味します.
)も参照してください.std::unique_ptrはこのようなタイプです.
元のオブジェクトが一時変数である場合、自動的に移動操作が行われますが、元のオブジェクトが名前付き変数である場合、移行時にstd::move()を使用して表示移動を行う必要があります.
スレッド所有権の転送

#include <iostream>
#include <thread>
void some_function(){}
void some_other_function(){}
int main()
{
	std::thread t1(some_function); // 1
	std::thread t2 = std::move(t1); // 2
	t1 = std::thread(some_other_function); // 3
	std::thread t3; // 4
	t3 = std::move(t2); // 5。t3:some_function;t1:some_other_function
	t1 = std::move(t3); // 6           
	system("pause");
	return 0;
}

関数間のスレッドの転送

#include <iostream>
#include <thread>
void some_function()
{
	std::cout << "hello" << std::endl;
}
std::thread f0()//      
{
	return std::thread(some_function);
}
void f(std::thread t)//      
{
	t.detach();//  
	//t.join();//  
}
void g()
{
	std::thread t0 = f0();//    ，    
	t0.join();
	f(std::thread(some_function));//    ，    
	std::thread t(some_function);
	f(std::move(t));//    ，    
}
void fun()
{
	std::thread t(some_function);
	t.detach();
	//or join()，    t             ，      
}
int main()
{
	fun();
	g();
	system("pause");
	return 0;
}

scoped_threadクラス:スレッドプログラムが終了する前に完了することを確認します

#include <iostream>
#include <thread>
void some_function()
{
	std::cout << "hello" << std::endl;
}
void do_something(const int &i)
{
	std::cout << i << std::endl;
}
class scoped_thread
{
	std::thread t;
public:
	explicit scoped_thread(std::thread t_) : // 1
		t(std::move(t_))
	{
		if (!t.joinable()) // 2
			throw std::logic_error("No thread");
	}
	~scoped_thread()
	{
		t.join(); // 3
	}
	scoped_thread(scoped_thread const&) = delete;
	scoped_thread& operator=(scoped_thread const&) = delete;
};
struct func
{
	int& i;
	func(int& i_) : i(i_) {}
	void operator() ()
	{
		for (unsigned j = 0; j<10; ++j)
		{
			do_something(i); //       ：    
			std::cout <<"\t"<< j << std::endl;
		}
	}
};
void f()
{
	int some_local_state{ 0 };
	std::thread t{ func(some_local_state) };//       
	t.join();
	scoped_thread st{ std::thread(func(some_local_state)) }; 
	//        ，            
	some_function();
} // 5

int main()
{
	f();
	system("pause");
	return 0;
}

量産スレッド、終了待ち

#include <iostream>
#include <thread>
#include <vector>
#include <algorithm>
void do_work(unsigned id)
{
	std::cout << id << std::endl;
}
void f()
{
	std::vector<std::thread> threads;
	for (unsigned i = 0; i < 20; ++i)
	{
		threads.push_back(std::thread(do_work, i)); //     
	}
	std::for_each(threads.begin(), threads.end(),
		std::mem_fn(&std::thread::join)); //        join(),for_each  :<alogrithm>
}
int main()
{
	f();
	system("pause");
	return 0;
}

クリックしてリンクを開く:for_についてeachアルゴリズムにおけるmem_fnの使用.
オリジナルパラレル版std::accumulate

#include <iostream>
#include <thread>
#include <vector>
#include <numeric>
#include <algorithm>
template<typename Iterator, typename T>
struct accumulate_block
{
	void operator()(Iterator first, Iterator last, T& result)
	{
		result = std::accumulate(first, last, result);
	}
};

template<typename Iterator, typename T>
T parallel_accumulate(Iterator first, Iterator last, T init)
{
	unsigned long const length = std::distance(first, last);
	if (!length) //   
		return init;
	unsigned long const min_per_thread = 25;//        
	unsigned long const max_threads =
		(length + min_per_thread - 1) / min_per_thread; //      
	unsigned long const hardware_threads =
		std::thread::hardware_concurrency();
	unsigned long const num_threads = // min(     ，       )=N
		std::min(hardware_threads != 0 ? hardware_threads : 2, max_threads);
	unsigned long const block_size = length / num_threads; //           
	std::vector<T> results(num_threads);//          ，      0
	std::vector<std::thread> threads(num_threads - 1); //    N-1     
	Iterator block_start = first;
	for (unsigned long i = 0; i < (num_threads - 1); ++i)//N-1
	{
		Iterator block_end = block_start;
		std::advance(block_end, block_size); //       
		threads[i] = std::thread( // ref，  N-1   ，         
			accumulate_block<Iterator, T>(),
			block_start, block_end, std::ref(results[i]));
		block_start = block_end; //       
	}
	accumulate_block<Iterator, T>()(
		block_start, last, results[num_threads - 1]); //       N   
	std::for_each(threads.begin(), threads.end(),
		std::mem_fn(&std::thread::join)); //   
	return std::accumulate(results.begin(), results.end(), init); //              
}

int main()
{
	std::vector<int> v(10000000, 3);
	int r0 = parallel_accumulate(v.cbegin(), v.cend(), 0);//135ms
	int r1 = std::accumulate(v.cbegin(), v.cend(), 0);//285ms
	std::cout << r0 << std::endl << r1 << std::endl;
	system("pause");
	return 0;
}

は元素の数が多いときに非常によく表現されています.
識別スレッド1、スレッド識別タイプ:std::thread::id.
2、検索方式:
A、std::thread t; t.get_からid()を直接取得します.std::threadオブジェクトが実行スレッドに関連付けられていない場合、get_id()はstd::thread::typeデフォルト構築値を返します.この値は「スレッドがありません」を表します.
B、現在のスレッドでstdを呼び出す::this_thread::get_id()(この関数はヘッダファイルに定義されている)もスレッド識別を得ることができる.
3、std::thread::idオブジェクトは、識別子が多重化できるため、自由にコピーおよび比較できます.

#include <iostream>
#include <thread>
void fun()
{
	std::cout << "fun()" << std::endl;
}
int main()
{
	std::thread t0{ fun };	
	std::thread t1{ fun };
	t1.detach();
	std::cout <<"   \t"<< t0.get_id()<<"\t" << t1.get_id() << std::endl;//     ，    ：0
	t0.join();
	std::cout << "   \t" << std::this_thread::get_id() << std::endl;
	std::hash<std::thread::id> ha;//       
	system("pause");
	return 0;
}

デフォルトページindex.jspから*.actionへジャンプ

C++インタフェース(抽象クラス)