有三种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();
}