《C++ Concurrency in Action》读书笔记一 多线程与线程管理

简介，c++11 中STL标准加入了对多线程的支持。现在可以直接使用STL::thread来创建线程并且对线程进行管理

Cp1.通过一个hello world的例子引入C++11 中多线程的支持

#include <iostream>
#include <thread>

void hello()
{
std::cout<<"Hello Concurrency World"<<std::endl;
}

int main()
{
std::thread t(hello);
t.join();

return 0;
}

Cp2.线程管理

1. 基本线程管理

1）std::thread的构造函数支持任何的std::function 比如函数，函数对象，lambda表达式等。作为std::thread的构造函数之参数。

2）线程启动以后可以选择join等待线程函数返回 或者deatch让其自动运行而不等待其返回。

join会等待线程执行结束而回收资源，detach调用之后会让线程成为守护线程资源回收交给runtime library管理

如果不执行join也不执行detach 会导致std::thread对象在退出栈的时候调用std::terminate()强制结束程序。

使用G++ 4.9.2 编译器执行的效果

3) 为了防止线程由于遇到exception而不能调用join来释放std::thread的资源，

可以使用try catch语句在catch中调用t.join在函数退出之前来等待线程结束。

使用类的析构函数来回收资源

#include <iostream>
#include <thread>

class thread_guard{
public:
thread_guard(std::thread & t_):t(t_)
{

}
~thread_guard()
{
if(t.joinable()){
t.join();
std::cout<<"free the resource for the std::thread"<<std::endl;
}
}
private:
std::thread& t;
};
void hello()
{
std::cout<<"Hello Concurrency World"<<std::endl;
}

int main()
{
std::thread t(hello);
thread_guard g(t);

//do something else.
return 0;
}

使用RAII tr1::shared_ptr<std::thread> threadptr(thread_function, delete_function);

#include <iostream>
#include <thread>
#include <tr1/memory>

void hello()
{
std::cout<<"Hello Concurrency World"<<std::endl;
}

void release_thread(std::thread *t)
{
if(t->joinable())
{
t->join();
std::cout<<"free the resource for the std::thread"<<std::endl;
}
}

int main()
{
std::thread * t = new std::thread(hello);
std::tr1::shared_ptr<std::thread> g(t, release_thread);

//do something else.
return 0;
}

4）让线程在后台运行detach()

目标线程就成为了守护线程（daemon threads）驻留后台运行，与之关联的std::thread对象失去对目标线程的关联，无法再通过std::thread对象取得该线程的控制权。调用joinable()返回false。

2.传递参数给线程函数

1）参数默认是以拷贝方式传递给线程函数，就算线程函数的参数列表本身是引用方式，因为std::thread的构造函数默认并不知道线程函数的参数是引用。

这时候可以使用std::ref(parameter)强制以引用方式传递参数。

2）将对象的成员函数传递给std::thread的构造函数

class X{
public:
void do_something(){};
};

X my_x;
std::thread t(&X::do_something, &my_x)

这等效于调用了my_x.do_something()

3)传递只能move不可copy的参数例如std::unique_ptr

std::unique_ptr<int> p(10);

std::move(p);

3.传递std::thread的管理权

1）std::thread对象类似std::unique_ptr一样是不可copy但是可以move。

注意以下例子

std::thread t1(some_func1);
std::thread t2(some_func2);
t1 = std::move(t2); //这会导致程序强制结束std::terminate();

2）std::thread可以作为函数的返回值 可以作为函数的参数传递

std::thread f()
{
void some_function();
return std::thread(some_function);
}

4.运行时选择创建线程的数量

1）创建复数的线程并等待他们结束

std::vector<std::thread> threads;
for(unsigned i=0; i<20; ++i)
{
threads.push_back(std::thread(do_work));
}
std::for_each(threads.begin(), threads.end(), std::mem_fn(&std::thread::join));

2) std::thread::hardware_concurrency() 返回一个程序可以执行的最大线程数。在多核系统上通常是cpu的核心数。

一个并行计算累积的例子

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_thread = (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);

unsigned long const block_size = length/num_threads;

std::vector<T> results(num_threads);
std::vector<std::thread> threads(num_threads-1);

Iterator block_start = first;
for(unsigned long i=0; i<(num_threads-1); ++i)
{
Iterator block_end = block_start;
std::advance(block_end, block_size);
threads[i] = std::thread(
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]);
std::for_each(threads.begin(), threads.end(),
std::mem_fn(&std::thread::join));

return std::accumulate(results.begin(), results.end(), init);
}

5. 标示线程

std::thread::id 使用get_it()函数

使用std::cout 输出id

std::cout<<std::this_thread::get_id();