C++11新特性 thread线程类

文章目录

- [1 线程的创建](#1 线程的创建)
- 给线程传递类成员函数
- [2 成员函数](#2 成员函数)
- - [2.1 get_id()](#2.1 get_id())
  - [2.2 join()](#2.2 join())
  - [2.3 detach()](#2.3 detach())
  - [2.4 joinable()](#2.4 joinable())
  - [2.5 operator=](#2.5 operator=)
- [3 静态函数](#3 静态函数)

每个进程都占用一个虚拟地址空间，但是进程中不管创建多少线程都共用一个地址空间

1 线程的创建

构造方式：

空构造，无意义
传有名函数，传函数名和函数的参数列表
传匿名函数,伪函数
移动构造，使用move（th1）转移线程所有权，之后th1不再表示线程

cpp 复制代码

#include <iostream>
#include <thread>
void callback(int age)
{
    std::cout << "我是:" << std::this_thread::get_id() << " 年龄是：" << age << std::endl;
}
int main()
{
    std::cout << std::this_thread::get_id() << std::endl;
    std::thread th1(callback, 10);
    std::cout << "th1:" << th1.get_id() << std::endl;
    std::thread&& th2 = move(th1);
    std::cout << "th2:" << th2.get_id() << std::endl;
    std::thread th3([=](int id){
    std::cout << "我是" << id << std::endl;
    }, 6121);
    // th1.join();
    th2.join();
	th3.join();
    return 0;
}

move变更所有权，th1已经不存在了，th1曾经拥有的现在就是th2，所以th1.join是错误的
同时，callback函数只执行1次，th2接管th1时，任务已经完成了

给线程传递类成员函数

cpp 复制代码

class Base
{
    void add(int a, int b)
    {
        cout << a + b << endl;
    }
    static void message(){
        cout << "create success." << endl;
    };
}

如果是静态成员函数，他是属于类的，传递这个函数和所属的类的地址就可以

cpp 复制代码

thread th1(&Base::message);

如果是非静态成员函数，他是属于对象的，需要先实例化对象

cpp 复制代码

Base b;
thread th2(&Base::add, b, 1, 2); //add函数属于Base类的对象b， 1 + 2
thread th3(&Base::add, &b, 1, 2); // 传入对象和对象的引用都是可以的
// 也可以使用bind函数进行绑定
#include <functional>
thread th4(bind(&Base::add, b, placeholder::_1, 2), 1)； //示例对象同样是可以传对象可以传引用

2 成员函数

2.1 get_id()

2.2 join()

如果不加这个函数，主线程执行完就退出了，释放了虚拟地址空间，但是子线程还没执行完，有的线程可能都没有机会执行

这个函数是子线程调用，但是阻塞的是主线程，直到调用它的子线程执行完，主线程才解除阻塞

调用的位置不一定是最后，需要根据线程的任务需求来判断阻塞的时机，假如是一个下载任务，那子线程下载完成后，主线程做一下校验

2.3 detach()

主线程和子线程的分离，由子线程调用，调用之后：

主线程不能访问子线程的资源，比如访问子线程的id
无法调用join函数
就是说主线程失去对子线程的控制，也不管他的死活，但是主线程退出，子线程也无法运行

2.4 joinable()

父子进程是否是关联的

2.5 operator=

移动是允许的，拷贝是不允许的，资源是不能复制的

3 静态函数

cpp 复制代码

std::thread::hardware_concurrency();

获取cpu核心数，如果让每个线程独自占有一个cpu的核，那么他们之间是并行的，效率是最高的