C++ 多线程

本文内容是《深入应用C++11 代码优化与工程级应用》的学习记录

1.使用join函数阻塞主线程

#include <thread>

void func()
{
    //do some work
}

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

    return 0;
}

提供线程函数func给std::thread类型的对象t，函数func将运行于线程对象t中，join函数会阻塞主线程，直到线程函数执行结束。

2. std::thread的get_id()方法

#include <thread>
#include <iostream>
void func()
{
    //do some work
    std::cout<<__FILE__<<"["<<__LINE__<<"]"<<std::this_thread::get_id()<<'\n';    //第6行
}

int main()
{
    std::thread t(func);
    std::cout<<__FILE__<<"["<<__LINE__<<"]"<<t.get_id()<<'\n';                    //第12行
    t.join();
    std::cout<<__FILE__<<"["<<__LINE__<<"]"<<std::this_thread::get_id()<<'\n';    //第14行
    return 0;
}

...\demo\main.cpp[12]2

..\demo\main.cpp[6]2

..\demo\main.cpp[14]1

线程对象t的id是2

主线程的id是1

 线程对象就代表着一个线程。

3.获得CPU核心数量（我的电脑是8核CPU）

#include <thread>
#include <iostream>

int main()
{
    std::cout<<__FILE__<<"["<<__LINE__<<"]"<<std::thread::hardware_concurrency()<<'\n';   
    return 0;
}

4. std::this_thread::sleep_for(std::chrono::seconds(3));

使当前线程休眠3s。

示例：

#include <thread>
#include <future>
#include <iostream>
void func()
{
    std::this_thread::sleep_for(std::chrono::seconds(3));
    for(int i = 10;i < 20;i++)
    {
        std::cout<<__FILE__<<"["<<__LINE__<<"]"<<i<<std::endl;
    }
}

int main()
{
    std::thread t(func);
    for(int i = 0;i < 9;i++)
    {
        std::cout<<__FILE__<<"["<<__LINE__<<"]"<<i<<std::endl;
    }
    t.join();
    return 0;
}

开始时线程对象t代表的线程会休眠3s，此时主线程正常打印，然后线程对象t代表的线程苏醒，开始打印。

5.需要注意线程对象的生命周期。

#include <thread>
#include <future>
#include <iostream>
void func()
{
    for(int i = 10;i < 200;i++)
    {
    }
}

int main()
{
    std::thread t(func);
    for(int i = 0;i < 9;i++)
    {
    }
    return 0;
}

这样写会抛出异常。

因为线程对象t先于线程函数func结束了。

6.线程异步和线程同步

线程同步：

多个线程需要同时访问同一个资源时，需要以某种顺序确保该资源在某一时刻只能被一个线程使用，否则程序的运行结果将不可预料，此时必须对数据进行同步。 

线程异步：

不同的线程之间，不一定都是竞争同一资源的并且如果它们相互之间状态或行为不影响，便可以分别进行，同时开展。 

区别：

7.call_once/once_flag的使用

为了保证在多线程环境中某个函数仅被调用1次，比如，需要初始化某个对象，而这个对象只能初始化一次时，就可以用std::call_once来保证函数在多线程环境中只被调用1次。

使用std::call_once时，需要一个once_flag作为call_once的第一个参数。

#include <thread>
#include <mutex>
#include <iostream>
std::once_flag flag;

void do_once()
{
    std::call_once(flag,[](){std::cout << "Called once" << std::endl;});
}

int main()
{
    std::thread t1(do_once);
    std::thread t2(do_once);
    std::thread t3(do_once);

    t1.join();
    t2.join();
    t3.join();
    return 0;
}

 

8. std::lock_guard

std::lock_guard 在其构造函数中自动获取互斥量的所有权，并在其析构函数中自动释放互斥量。这意味着，只要 std::lock_guard 对象存在，它所管理的互斥量就会保持锁定状态。当 std::lock_guard 对象被销毁（例如，当它离开作用域时），互斥量会自动解锁。