c++ concurrency in action 学习总结第二章

有三种callable 的thread launch

然后wait for thread to complete

一定要detach join 

而且还有个例外是exception

2.

运行同一程序的不同内容，可以让新内容detached

开线程除了pass the function name to the thread constructor 

例如 std::thread t(function name)

还可以在same function 的基础上

pass value 

例如 

std::thread t(function_name , value)

这样带来的坏处可能是传参的类别，有std::string 与const char*的区别

也有 reference 和value 的区别 

2.1supply arg 的scenario

一个scenario 就是在std::bind里面

题外话：这样总结没什么卵用，还不如总结大类

另外个scenario就是std::move to transfer the ownship of the dynamic object.

线程还会terminateif  already has one.

然而还有专门的threadguard类 prevent 若是线程不能join 的情况下强行pass value的情况

std::vector<std::thread>threads to manage the threads

3下面是一个简单的多线程叠加的例子

#include <thread>
#include <numeric>
#include <algorithm>
#include <functional>
#include <vector>
#include <iostream>

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 =
		std::min(hardware_threads != 0 ? hardware_threads : 2, max_threads);//防止多开线程，这里的threads是一个核开的线程，如果是单核，你可以选择一个核开两个线程。

	unsigned long const block_size = length / num_threads;//这里是一个核计算的范围 比如说1-10 4核 每核范围2.5

	std::vector<T> results(num_threads);//每个核计算的结果
	std::vector<std::thread>  threads(num_threads - 1);//额外开的线程

	Iterator block_start = first;//block_start是个函数的括号外变量
	for (unsigned long i = 0; i<(num_threads - 1); ++i)
	{
		Iterator block_end = block_start;
		std::advance(block_end, block_size);//block_end是一个迭代器，block_size 是个数字,就是block_end跃迁了block_size的位置0+2.5
		threads[i] = std::thread(
			accumulate_block<Iterator, T>(),
			block_start, block_end, std::ref(results[i]));//之前所说的类中，这种其实叫functor，传值
		block_start = block_end;//跃迁之后，起点定在2.5 ，对应之前的循环外变量
	}
	accumulate_block<Iterator, T>()(block_start, last, results[num_threads - 1]); //累积

	std::for_each(threads.begin(), threads.end(),
		std::mem_fn(&std::thread::join));//join threads容器

	return std::accumulate(results.begin(), results.end(), init);//容器相加
}

int main()
{
	std::vector<int> vi;

	unsigned long const hardware_threads =
		std::thread::hardware_concurrency();
	for (int i = 0; i<10; ++i)
	{
		vi.push_back(10);
	}
	int sum = parallel_accumulate(vi.begin(), vi.end(), 5);
	std::cout << hardware_threads << std::endl;

	std::cout << "sum=" << sum << std::endl;
	std::cin.get();
}