C++并发编程 _管理线程-Aet

Bingliaolong 2020-05-07 10:38 Aet | 隐藏边栏 | 抢沙发 | 9 0

文章评分 6 次，平均分 5.0 ：

介绍

每个C++进程都拥有至少一个线程，它是由C++在运行时启动的。该线程运行着main()函数。

我们自己的程序可以继续启动具有其他函数作为入口的线程。然后，这些线程连同初始线程一起，并发运行。

正如程序会在main()函数返回时退出那样，当指定的入口函数返回时，该线程就会退出。

启动线程

可以传给thread对象一个可调用对象，来启动线程

可调用对象

函数

函数指针

lambda表达式

bind()创建的对象

重载了函数调用运算符的类

void do_some_thing();

std::thread my_thread(do_some_thing);

calss background_task

{

public:

void operator() const

{

do_some_thing();

do_some_thing_else();

}

};

background_task f;

std::thread my_thread(f);

上述情况，所提供的函数对象将被复制到属于新创建的执行线程的存储器中，并从那里调用。

1	std::thread my_thread([]{do_some_thing();});

等待线程完成

可以通过join()来完成

join()的行为会清理所有与该线程相关联的存储器，会导致std::thread对象不再与已完成的线程相关联。

也就是意味着，一旦调用了join()，此std::thread对象不再是可连接的，joinable()将返回false。

在异常环境下的等待

struct func;

void f()

{

int some_local_stat = 0;

func my_func(some_local_stat);

std::thread my_thread(my_func);

try

{

do_some_thing_in_cur_thread();

}

catch(...)

{

my_thread.join();//异常中断

throw;

}

my_thread.join();//正常退出

}

上述方法不好，比较啰嗦，容易将作用域弄乱

下面使用RAII（资源获取即初始化）的做法

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&) = delete;

};

struct func;

void f()

{

int some_local_stat = 0;

func my_func(some_local_stat);

std::thread my_thread(my_func);

thread_guard g(my_thread);

do_some_thing_in_cur_thread();

}//4

4
- 对象g先被析构
1
- 在析构中先判断线程是否可结合
2
- 在析构中线程被结合，这样后面的do_some_thing_in_cur_thread()是否发生异常，线程都会被结合
3
- 拷贝构造和赋值运算符被禁用，避免thread_guard对象可能比它结合的线程的作用域的声明周期更长的情况

后台运行线程

可以通过detach()来完成

它会把线程丢在后台运行，我们没有直接的方法与之通信

如果一个线程成为分离的，获取一个引用它的std::thread对象是不可能的。所以它也不能再被结合。

分离的线程的所有权和控制权都交给了C++运行时库，以确保线程相关联的资源在线程退出后能够正确地回收。

按照UNIX的守护进程的概念，被分离的线程通常被称作为守护线程。

std::thread t(do_some_thing());

t.detach();

assert(!t.joinable());

//预处理宏 assert()在标准库头文件 cassert 中定义。它可以在程序中测试逻辑表达式。

//只要条件（表达式）是 false，assert()宏就会调用 std::abort()，终止程序。

传参给线程

1 2	void f(int i,std::string const& s); std::thread t(f,3,"hello");

void f(int i,std;:string const& s);

void oops(int some_param)

{

char buffer[1024];

sprintf(buffer,"%i",some_param);

std::thread t(f,3,buffer);

t.detach();

}

//buffer会在新线程中被转换为string之前，oops退出，buffer释放

//修改如下：

void f(int i,std::string const& s);

void oops(int some_param)

{

char buffer[1024];

sprintf(buffer,"%i",some_param);

std::thread t(f,3,std::string(buffer));

t.detach();

}

//想要的是引用，但传过去的其实不是

void update(Widget_id w,Widget_data& data);

void oops_again(Widget_id w)

{

Widget_data data;

std::thread t(update,w,data);//传递过去的并非引用

display();

t.join();

process_widget_data(data);//拿到的最新的data也并不是经过处理的data

}

//修改如下：

void update(Widget_id w,Widget_data& data);

void oops_data(Widget_id w)

{

widget_data data;

std::thread t(update,w,std::ref(data));

display();

t.join();

process_widget_data(data);

}

//传递成员函数给线程

class X

{

public:

void do_something();

};

X my_x;

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

转移线程所有权

void some_function();

void some_other_function();

std::thread t1(some_function);

std::thread t2 = std::move(t1);//所有权移到t2

t1 = std::thread(some_other_function);//t1由于新线程所有权

std::thread t3;//没有绑定函数的线程

t3 = std::move(t2);//t3拥有some_function对应线程所有权

t1 = std::move(t3);//试图将一个线程对象关联线程所有权给到另一个已经关联了线程所有权的对象，

//导致调用std::terminate()来终止程序

//从函数返回线程

std::thread f()

{

void some_function();

return std::thread(some_function);

}

std::thread g()

{

void some_other_function(int);

std::thread t(some_other_function,42);

return t;

}

//将线程所有权移给函数

void f(std::thread t);

void g()

{

void some_function();

f(std::thread(some_function));

std::thread t(some_function);

f(std::move(t));

}

//生成一批线程并等待它们完成

void do_work(unsigned id);

void f()

{

std::vector<std::thread> threads;

for(unsigned i = 0;i < 20; ++i)

threads.push_back(std::thread(do_work,i));

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

}

运行时选择线程数量

C++标准库中对此有帮助的特性是std::thread::hardware_concurrency().

这个函数返回一个对于给定程序执行时能够真正并发运行的线程数量的指示。

//test,假定所有操作都不引发异常

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)

{

const unsigned long length = std::distance(first,last);

if(!length)

return init;

const unsigned long min_per_thread = 25;

const unsigned long max_threads = (length+min_per_thread-1)/min_per_thread;

const unsigned long hardware_threads = std::thread::hardware_concurrency();

const unsigned long num_threads = std::min(hardware_threads!=0?hardware_threads:2,max_threads);

const unsigned long 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<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);

}

标识线程

线程标识符是std::thread::id类型的，并且有两种获取方式。

线程的标识符可以通过从与之相关联的std::thread对象中通过调用get_id()成员函数来获得。

如果std::thread对象没有相关联的执行线程，get_id()返回一个默认构造的std::thread::id对象，表示“没有线程”。

当前线程的标识符，可以通过调用std::this_thread::get_id()获得

定义在<thread>头文件中

另外，std::thread::id类型的对象可以自由地复制与比较：

两个std::thread::id类型的对象相等，则它们代表着同一个线程

两个std::thread::id类型的对象不相等，则它们代表不同线程或者其中一个代表着线程，另一个表示“没有线程”

两个std::thread::id类型的对象都具有“没有线程”

std::thread::id master_thread;

void some_core_part_of_algorithm()

{

if(std::this_thread::get_id() == master_thread)

do_master_thread_work();

do_common_work();

}

介绍
启动线程
等待线程完成
后台运行线程
传参给线程
转移线程所有权
运行时选择线程数量
标识线程

本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！

Bingliaolong 关注：0 粉丝：0 最后编辑于：2023-09-16

Everything will be better.

一	二	三	四	五	六	日
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

介绍

启动线程

等待线程完成

在异常环境下的等待

后台运行线程

传参给线程

转移线程所有权

运行时选择线程数量

标识线程

你可能也喜欢

热评文章

发表评论

标签云集