[原]std::thread总结

时间：2018-08-11 13:52:59 阅读：197 评论：0 收藏：0 [点我收藏+]

标签：play 拷贝 _id color microsoft fir join() cpp tor

原总结 C++11 thread

缘起
std::thread
参考资料

缘起

从C++11开始提供了线程的支持，终于可以方便的编写跨平台的线程代码了。除了std::thread类，还提供了许多其它便利同步的机制，本篇总结是C++11学习笔记系列的首篇总结。

std::thread

std::thread定义在<thread>中，提供了方便的创建线程的功能。

类定义

class thread 
{ 
public: 
    thread() noexcept; 
    thread( thread&& other ) noexcept; 
    template< class Function, class... Args > 
    explicit thread( Function&& f, Args&&... args ); 
    thread(const thread&) = delete; 
    ~thread(); 
    thread& operator=( thread&& other ) noexcept; 
    bool joinable() const noexcept; 
    std::thread::id get_id() const noexcept; 
    native_handle_type native_handle(); 
    void join(); 
    void detach(); 
    void swap( thread& other ) noexcept; 
    static unsigned int hardware_concurrency() noexcept; 
}; 

从定义中我们可以得知：

std::thread不支持拷贝语义。
std::thread支持移动语义。

各个成员函数的简单介绍

join() 可以用来等待线程结束，只能调用一次。
joinable()是否与某个有效的线程关联。
detach() 与当前线程分离。
swap() 与另外一个std::thread交换。
get_id()获取id。
native_handle() 返回平台相关的数据，windows下是HANDLE。
hardware_concurrency() 返回可并行运行的线程数量，只能作为一个参考。

例子

因为thread类比较简单，我们通过几个例子来学习。

支持移动语义，但不支持拷贝语义

#include <thread> 
void some_function() {} 
void some_other_function() {} 
int main() 
{ 
    std::thread t1(some_function); // 构造一个thread对象t1 
    std::thread t2 = std::move(t1); // 把t1 move给另外一个thread对象t2，t1不再管理之前的线程了。 
    // 这句不需要std::move()，从临时变量进行移动是自动和隐式的。调用的是operator=(std::thread&&) 
    t1 = std::thread(some_other_function); 
    std::thread t3; 
    t3 = std::move(t2); // 把t2 move给t3 
    // 把t3 move给t1，非法。因为`t1`已经有了一个相关的线程，会调用`std::terminate()`来终止程序。 
    t1 = std::move(t3); 
} 

通过调用join()成员函数来等待线程结束

#include <iostream> 
#include <thread> 
#include <chrono> 
  
void foo() { 
    std::this_thread::sleep_for(std::chrono::seconds(1)); 
} 
  
int main() { 
    std::cout << "starting first helper...\n"; 
    std::thread helper1(foo); 
    helper1.join(); 
} 

传递参数给线程函数

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的指针会被传递给新线程，如果oops()在buffer被转换成string之前退出，那么会导致未定义的行为。解决之道是在构造std::thread的时候传递string变量。std::thread t(f, 3, std::string(buffer));

因为默认会复制，如果像要传递引用，需要使用std::ref()来标识，就像std::bind()那样。

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

使用类的成员函数作为线程参数

#include <thread> 
#include <string> 
class CRunner 
{ 
public: 
    void run0(){} 
    void run1(int a) {} 
    void run2(int a, int b) {} 
    int  run3(int a, char b, const std::string& c) {return 0;} 
    int  run4(int& a, double b, float c, char d) { ++a; return 0; } 
    static void run_static(int a) {} 
}; 
 
int main() 
{ 
    CRunner runner; 
    int a = 0; 
    // 使用std::mem_fun 
    std::thread t0(std::mem_fun(&CRunner::run0), &runner); 
     // 使用std::mem_fun_ref，注意与std::mem_fun的区别 
    std::thread t1(std::mem_fun_ref(&CRunner::run1), std::ref(runner), 1); 
    // 使用std::mem_fn，std::mem_fn支持多于一个参数的函数，std::mem_fun不支持。 
    std::thread t2(std::mem_fn(&CRunner::run2), std::ref(runner), 1, 2); 
    // 使用std::bind + std::mem_fn 
    std::thread t3(std::bind(std::mem_fn(&CRunner::run3), &runner, 1, 2, "data"));  
    // 使用std::mem_fn，注意std::ref的用法，如果不用std::ref行不行？ 
    std::thread t4(std::mem_fn(&CRunner::run4), &runner, std::ref(a), 2.2, 3.3f, ‘d‘);  
    // 使用类的静态函数 
    std::thread t5(&CRunner::run_static, 1); 
 
    t0.join(); 
    t1.join(); 
    t2.join(); 
    t3.join(); 
    t4.join(); 
    t5.join(); 
} 

参考资料

《C++并发编程实战》
cppreference

[原]std::thread总结

标签：play 拷贝 _id color microsoft fir join() cpp tor

原文地址：https://www.cnblogs.com/bianchengnan/p/9459490.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行