C++11多线程: thread创建线程的三种方式

C++11 多线程相关的头文件

  • :该头文件用于线程操作,主要声明了 std::thread 类,另外 std::this_thread 命名空间也在该头文件中,包含一些线程的操作函数。
  • :该头文件用于互斥量操作,主要声明了与互斥量相关的类,包括 std::mutex 系列类,std::lock_guard,std::unique_lock,以及其他的类型和函数。
  • :该头文件用于条件变量操作,主要声明了与条件变量相关的类,包括 std::condition_variable 和 std::condition_variable_any。
  • :该头文件用于异步调用操作,主要声明了 std::promise,std::package_task 两个 Provider 类,以及 std::future 和 std::shared_future 两个 Future 类,另外还有一些与之相关的类型和函数,std::async() 函数就声明在此头文件中。
  • :该头文件用于原子操作,主要声明了两个类,std::atomic 和 std::atomic_flag,另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。

thread 详解

default (1) thread() noexcept;
initialization (2) template explicit thread (Fn&& fn, Args&&… args);
copy [deleted] (3) thread (const thread&) = delete;
move (4) thread (thread&& x) noexcept;
  • 默认构造函数,创建一个空的 thread 执行对象。
  • 初始化构造函数,创建一个 thread 对象,该 thread 对象可被 joinable,新产生的线程会调用 fn 函数,该函数的参数由 args 给出。
  • 拷贝构造函数(被禁用),意味着 thread 不可被拷贝构造。
  • move 构造函数,move 构造函数,调用成功之后 x 不代表任何 thread 执行对象。
    线程对象可以被 move,但是不能被拷贝。而对于 move 赋值操作,如果当前对象不可 joinable,需要传递一个右值引用给 move 赋值操作;如果当前对象可被 joinable,则 terminate() 报错。关于线程是否 joinable,可以通过调用 joinable() 来获得,更多关于 joinable 的资料,可以参考 std::thread::joinable
    注意:可被 joinable 的 thread 对象必须在他们销毁之前被主线程 join 或者将其设置为 detached。
  • std::thread 创建线程,需要提供线程函数或者函数对象,并可以同时指定线程的参数。
  • join函数将会阻塞线程,直到线程函数执行结束,如果线程函数有返回值,返回值将被忽略。join()函数的另一个任务是回收该线程中使用的资源。
  • detach可以将线程与线程对象分离,让线程作为后台线程执行,当前线程也不会阻塞了。但是detach之后就无法在和线程发生联系了。如果线程执行函数使用了临时变量可能会出现问题,因为线程调用了detach之后是在后台运行,临时变量可能已经销毁,那么线程会访问已经被销毁的变量会报错。而join能保证。
    线程对象和对象内部管理的线程的生命周期并不一样,如果线程执行的快,可能内部的线程已经结束了,但是线程对象还活着,也有可能线程对象已经被析构了,内部的线程还在运行。
    总结(针对detach())
    (1)若传递int这种简单类型参数,建议都是值传递,不要用引用
    (2)如果传递类对象,避免隐式类型转换。全部都要在创建线程就构建临时对象,然后函数参数中用引用,否则系统还会构造一次
  • joinable函数判断一个线程对象能否调用join()。

除了 join,detach,joinable 之外,std::thread 头文件还在 std::this_thread 命名空间下提供了一些辅助函数:

  • get_id: 返回当前线程的 id
  • yield: 告知调度器运行其他线程,可用于当前处于繁忙的等待状态
  • sleep_for:给定时长,阻塞当前线程
  • sleep_until:阻塞当前线程至给定时间点
    其中 yield 是一个特殊的“线程睡眠”函数:
    std::this_thread::yield() 是将当前线程所抢到的 CPU ”时间片A”让渡给其他线程(其他线程会争抢”时间片A”,注意。此时”当前线程”不参与争抢。等到其他线程使用完”时间片A”后,再由操作系统调度,当前线程再和其他线程一起开始抢 CPU 时间片。
    如果将 std::this_thread::yield() 上述语句修改为: return;,则将未使用完的 CPU ”时间片A”还给操作系统,再由操作系统调度,当前线程和其他线程一起开始抢CPU时间片。
    因此 yield 使用的场景就是当当前线程运行条件不满足时调用,避免一个线程频繁与其他线程争抢 CPU 时间片, 从而导致多线程处理性能下降。sleep_for 也是让线程等待,需要等待若干时间。
    Linux 下编译: g++ –std=c++11 sample.cpp -lpthread

thread多线程创建

std::thread类的构造函数是使用可变参数模板实现的,也就是说,可以传递任意个参数,第一个参数是线程的入口函数,而后面的若干个参数是该函数的参数。

我们可以给 std::thread 对象添加函数,这个回调函数将在这个新线程启动时执行。这些回调可以是:
1.) 函数指针
2.) 函数对象
3.) Lambda 函数

//创建 thread 对象:
std::thread thObj(<CALLBACK>);

新线程将在创建新对象后立即启动,并将并行地执行(当参数)传递给线程的回调函数。

使用函数指针创建线程

#include
#include
#include 
using namespace std;

//传入的不是myNum的引用,指向地址不同,实际是值传递,即便主线程detach(),子线程使用num不会出问题
//传入的指针依旧是指向muBuf的地址,所以detach后,子线程会出问题。可以将char*改为const string&
//使用const string&也有问题,即:不知道mybuf不知道什么时候转换为string,如果主线程执行完毕后,还没转换完毕,就有问题
void test(const int& num, char* buf) {
    for(int i = 0; i < 5; i++){
        cout << "线程1开始执行" << endl;
        cout << "num1 = " << num << endl;
        cout << "buf1 = " << buf << endl;
        cout << "线程1执行完毕" << endl;
    }

}

void test2(const int& num, const string& buf) {
    for(int i = 0; i < 5; i++) {
        cout << "线程2开始执行" << endl;
        cout << "num2 = " << num << endl;
        cout << "buf2 = " << buf << endl;
        cout << "线程2执行完毕" << endl;
    }
}
int main() {
    int myNum = 1;
    int& num = myNum;
    char myBuf[] = "only for test!";
    const string& myBuf2 = "buf2 only for test!";
    thread th(test, num, myBuf);
    thread th2(test2, num, myBuf2);
    //thread th2(test2,num,string(myBuf));// 针对detach ,生成一个临时string对象,绑定const string&,使用这个方法,就会让string对象在主线程执行完毕前构造 在创建线程的同时构造临时对象是可行的
    th.join();
    //th2.detach();
    th2.join();
    cout << "主线程执行完毕" << endl;
    return 0;
}

使用类对象创建线程

//使用类对象创建线程
#include
#include
using namespace std;

class Test {
public:
    Test(){
        cout << "Test()构造函数被执行" << endl;
    }
    Test(const Test& test) {
        cout << "拷贝构造函数执行" << endl;
    }
    ~Test() {
        cout << "析构函数执行" << endl;
    }
    void operator()() {//不能带参数
        cout << "线程开始执行" << endl;
        for (int i = 0; i < 10; ++i);
        cout << "线程执行完毕" << endl;
    }
};

int main() {
    Test test;
    thread th(test);
    th.detach();
    //th.join()
    for (int i = 0; i < 10; ++i) {
        cout << "主线程执行完毕" << i << endl;
    }
    return 0;
}

输出

Test()构造函数被执行
拷贝构造函数执行//证明确实复制了一份对象
拷贝构造函数执行
析构函数执行
主线程执行完毕0
主线程执行完毕1
主线程执行完毕2
主线程执行完毕3
主线程执行完毕4
主线程执行完毕5
主线程执行完毕6
主线程执行完毕7
主线程执行完毕8
主线程执行完毕9
析构函数执行//线程还没有执行完毕,所以这个析构是主线程对象
线程开始执行
线程执行完毕
析构函数执行

detach换成join的输出

Test()构造函数被执行
拷贝构造函数执行
拷贝构造函数执行
析构函数执行
线程开始执行
线程执行完毕
析构函数执行//此时主线程还未退出,但该线程执行完毕,所以这个析构对象是析构复制对象的
主线程执行完毕0
主线程执行完毕1
主线程执行完毕2
主线程执行完毕3
主线程执行完毕4
主线程执行完毕5
主线程执行完毕6
主线程执行完毕7
主线程执行完毕8
主线程执行完毕9
析构函数执行//此时主线程退出,所以这个析构对象是主函数中的对象

线程参数为引用时修改值,不会影响主线程的值

#include
#include
using namespace std;

class A {
public:
    mutable int num;//标注为const也能修改
    //类型转换构造函数,可以把一个int转换成一个类A对象
    A(int num) :num(num) {
        cout << "构造函数执行" << this << "threadid=" << std::this_thread::get_id() << endl;
    }
    A(const A& a) :num(a.num) {
        cout << "拷贝构造函数执行" << this << "threadid=" << std::this_thread::get_id() << endl;
    }
    ~A() {
        cout << "析构函数执行" << this << "threadid=" << std::this_thread::get_id() << endl;
    }
};

void test(const A& a) {
    a.num = 199;//修改不会影响main的值
    cout << "线程test的a.num=" << a.num << endl;
    cout << "线程test的参数地址是" << &a << "threadid=" << std::this_thread::get_id() << endl;
}

int main() {
    cout << "主线程id是" << std::this_thread::get_id() << endl;
    A a(10);
    thread th(test, a);//将类对象作为线程参数
    th.join();
    cout << "主线程的a.num=" << a.num << endl;
    cout << "主线程执行完毕" << endl;
    return 0;
}

输出

主线程id是140575262807872
构造函数执行0x7ffd04eaf38cthreadid=140575262807872
拷贝构造函数执行0x7ffd04eaf340threadid=140575262807872
拷贝构造函数执行0x56237eb422c8threadid=140575262807872
析构函数执行0x7ffd04eaf340threadid=140575262807872
线程test的a.num=199
线程test的参数地址是0x56237eb422c8threadid=140575262803712
析构函数执行0x56237eb422c8threadid=140575262803712
主线程的a.num=10
主线程执行完毕
析构函数执行0x7ffd04eaf38cthreadid=140575262807872

std::ref函数,可以让线程传入的参数不被复制(注:没使用detach())

//将线程传入参数加上std::ref
thread th(test, std::ref(a));
//主线程的a.num = 199,被成功修改

传递智能指针

#include
#include

using namespace std;

void test(unique_ptr<int> uptr) {
    cout << "子线程id是" << std::this_thread::get_id() << endl;
    cout <<  "当前智能指针的值是" << *uptr << endl;
}

int main() {
    cout << "主线程id是" << std::this_thread::get_id() << endl;
    unique_ptr<int> uptr(new int(10));
    cout << "当前智能指针的值为"  << *uptr << endl;
    thread th(test, std::move(uptr));//将类对象作为线程参数
    th.join();
    cout << "主线程执行完毕" << endl;
    return 0;
}

若改为detach(),当主线程执行完毕后,uptr被释放,但子线程还在执行,此时就会出现问题

成员函数指针做线程函数

#include
#include
using namespace std;

class A {
public:
    mutable int num;
    //类型转换构造函数,可以把一个int转换成一个类A对象
    A(int num) :num(num) {
        cout << "构造函数执行, " << this << "threadid=" << std::this_thread::get_id() << endl;
    }
    A(const A& a) :num(a.num) {
        cout << "拷贝构造函数执行, " << this << "threadid=" << std::this_thread::get_id() << endl;
    }
    ~A() {
        cout << "析构函数执行, " << this << "threadid=" << std::this_thread::get_id() << endl;
    }
    void thread_work(int num) {
        num = 199;//修改不会影响main的值
        cout << "子线程num=" << num << endl;
        cout << "子线程thread_work执行了, " << "threadid=" << std::this_thread::get_id() << endl;
    }
};

void test(const A& a) {
    a.num = 199;//修改不会影响main的值
    cout << "a.num=" << a.num << endl;
    cout << "线程test的参数地址是" << &a << "threadid=" << std::this_thread::get_id() << endl;
}

int main() {
    cout << "主线程id是" << std::this_thread::get_id() << endl;
    A a(10);
    int num = 100;
    //第一个参数是对象函数指针,第二个参数对象,其后参数为函数所需参数
    thread th(&A::thread_work, a,num);
    th.join();
    cout << "主线程的num=" << num << endl;
    cout << "主线程的a.num=" << a.num << endl;
    cout << "主线程执行完毕" << endl;
    return 0;
}

使用 Lambda 函数创建线程

#include
#include
using namespace std;
int main() {
    auto test = [] {
        cout << "线程开始执行" << endl;
        for (int i = 0; i < 10; ++i);
        cout << "线程执行完毕" << endl;
    };
    thread th(test);
    th.join();
    cout << "主线程执行完毕"  << endl;
    return 0;
}

如何区分线程: 线程ID

每个 std::thread 对象都有一个 ID,使用下面的函数可以获取:

std::thread::get_id()

如果 std::thread 对象没有和任何对象关联,则 get_id() 函数会返回默认构造的 std::thread::id 对象,即“非线程”。
获取当前线程的 ID:

std::this_thread::get_id()

用法示例

#include 
#include 
void thread_function()
{
    std::cout<<"Inside Thread :: ID  = "<<std::this_thread::get_id()<<std::endl;
}
int main()
{
    std::thread threadObj1(thread_function);
    std::thread threadObj2(thread_function);

    if(threadObj1.get_id() != threadObj2.get_id())
        std::cout<<"Both Threads have different IDs"<<std::endl;

    std::cout<<"From Main Thread :: ID of Thread 1 = "<<threadObj1.get_id()<<std::endl;
    std::cout<<"From Main Thread :: ID of Thread 2 = "<<threadObj2.get_id()<<std::endl;

    threadObj1.join();
    threadObj2.join();
    return 0;
}
#include
#include
using namespace std;

class A {
public:
    int num;
    //类型转换构造函数,可以把一个int转换成一个类A对象
    A(int num) :num(num) {
        cout << "构造函数执行" << this << "threadid=" << std::this_thread::get_id() << endl;
    }
    A(const A& a) :num(a.num) {
        cout << "拷贝构造函数执行" << this << "threadid=" << std::this_thread::get_id() << endl;
    }
    ~A() {
        cout << "析构函数执行" << this << "threadid=" << std::this_thread::get_id() << endl;
    }
};

void test(const A& a) {
    cout << "线程test的参数地址是" << &a << "threadid=" << std::this_thread::get_id() << endl;
}

int main() {
    cout << "主线程id是" << std::this_thread::get_id() << endl;
    int num = 2;
    thread th(test, num);
    th.join();
    cout << "主线程执行完毕" << endl;
    return 0;
}

参考

C++11 并发编程系列(一):多线程初探(thread)
[c++11]多线程编程(二)——理解线程类的构造函数
C++11多线程编程
c++11线程基本用法
[c++11]多线程编程(一)——初识

你可能感兴趣的:(笔记,c++,多线程)