C++ std::thread 多线程

本文主要是介绍C++ std::thread 多线程，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1. 创建线程
- 1.1. move & bind
- 1.2. 区分线程
- 1.3. 传参
- 1.4. 从线程返回值
- 1.5. thread_local
2. 同步 & 互斥
- 2.1. std::mutex
  - 2.1.1. std::lock_guard
  - 2.1.2. std::unique_lock
  - 2.1.3. 4种互斥量：递归/超时
- 2.2. 条件变量
- 2.3. 信号量
3. std::async()

1. 创建线程

创建线程的三种不同方式

那么std::thread在构造函数中接受什么？我们可以在std::thread对象上附加一个回调，该回调将在新线程启动时执行。这些回调可以是：

函数指针

void thread_function(){
    for (int i = 0; i < 10000; i++);
    std::cout << "thread function Executing" << std::endl;
}

// 创建线程
std::thread threadObj(thread_function);

函数对象

class DisplayThread{
public:
    void operator()(){
        std::cout << "Display Thread Executing" << std::endl;
    }
};

int main()
{
    std::thread tid((DisplayThread()));
    tid.join();
}

类成员方法（指针）

class Producer{
public:
    Producer(){};
    ~Producer() = default;

    void create(){
        cout << "create product: " << this->_no << endl;
        ++_no;
    }

private:
    int _no = 100;
};

int main(){
    thread tid(&Producer::create, Producer());
    tid.join();
}

示例2

#include <iostream>
#include <vector>
#include <thread>
class Wallet
{
    int mMoney;
public:
    Wallet() :mMoney(0) {}
    int getMoney() {
        return mMoney;
    }
    void addMoney(int money)
    {
        for (int i = 0; i < money; ++i)
        {
            mMoney++;
        }
    }
};

int testMultithreadedWallet()
{
    Wallet walletObject;
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i)
    {
        threads.push_back(std::thread(&Wallet::addMoney, &walletObject, 100000));
    }
    for (int i = 0; i < threads.size(); i++)
    {
        threads.at(i).join();
    }
    return walletObject.getMoney();
}

int main()
{
    int val = 0;
    for (int k = 0; k < 10; k++)
    {
        if ((val = testMultithreadedWallet()) != 500000)
        {
            std::cout << "Error at count = " << k << " Money in Wallet = " << val << std::endl;
        }
    }
    return 0;
}

Lambda函数

std::thread threadObj([] {
        for (int i = 0; i < 10; i++)
            std::cout << "Display Thread Executing" << std::endl;
    });

1.1. move & bind

通过std::thread创建的线程是不可以复制的，但是可以移动。

std::thread t1(threadfunc);
std::thread t2(std::move(t1));

移动后t1就不代表任何线程了，t2对象代表着线程 threadfunc() 。

另外，还可以通过 std::bind 来创建线程函数。

class A {
public:
    void threadfunc(){
        std::cout << "bind thread func" << std::endl;
    }
};

A a;
std::thread t1(std::bind(&A::threadfunc,&a));
t1.join();

创建一个类A，然后再main函数中将类A中的成员函数绑定到线程对象t1上。

1.2. 区分线程

std::thread::get_id()

要获取当前线程使用的标识符,即

std::this_thread::get_id()

1.3. 传参

简单传参

void threadCallback(int x, std::string str);
std::thread threadObj(threadCallback, n, str);

如何不将参数传递给c++11中的线程
如何在c++11中传递对std::thread的引用

线程函数threadCallback中的x引用了在新线程的堆栈上复制的临时值。如何解决呢？使用 std::ref() 即可。 std::ref 用于包装按引用传递的值。
```
void threadCallback(int const & x)
std::thread threadObj(threadCallback, std::ref(x));
```

将指向类成员函数的指针分配为线程函数

class DummyClass {
public:
    DummyClass()
    {}
    DummyClass(const DummyClass & obj)
    {}
    void sampleMemberFunction(int x)
    {
        std::cout<<"Inside sampleMemberFunction "<<x<<std::endl;
    }
};

DummyClass dummyObj;
int x = 10;
std::thread threadObj(&DummyClass::sampleMemberFunction,&dummyObj, x);

1.4. 从线程返回值

很多时候，我们遇到希望线程返回结果的情况。现在的问题是如何做到这一点？让我们举个例子假设在我们的应用程序中，我们创建了一个将压缩给定文件夹的线程，并且我们希望该线程返回新的zip文件名及其结果。现在，我们有两种方法：

使用指针在线程之间共享数据

将指针传递给新线程，此线程将设置其中的数据。在此之前，在主线程中使用条件变量继续等待。当新线程设置数据并向条件变量发送信号时，主线程将唤醒并从该指针获取数据。为了简单起见，我们使用了一个条件变量，一个互斥锁和一个指针(即3个项)来捕获返回的值。为那么问题将变得更加复杂。

有没有一个简单的方法从线程返回值？答案是肯定的，继续往下看。
使用std::future

std::future是一个类模板，其对象存储将来的值。那么这future模板有什么用？实际上，一个std::future对象在内部存储了将来将分配的值，并且还提供了一种访问该值的机制，即使用get()成员函数。但是，如果有人尝试在get()函数可用之前访问future的此关联值，则get()函数将阻塞直到该值不可用。 std::promise也是一个类模板，其对象承诺将来会设置该值。每个std::promise对象都有一个关联的std::future对象，一旦std::promise对象设置了该值，它将给出该值。一个std::promise对象与其关联的std::future对象共享数据。让我们一步一步来看看，在Thread1中创建一个std::promise对象。

截至目前，该promise对象没有任何关联值。但是它提供了一个保证，肯定有人会在其中设置值，一旦设置了值，您就可以通过关联的std::future对象获得该值。但是现在假设线程1创建了这个promise对象并将其传递给线程2对象。现在，线程1如何知道何时线程2将在此promise对象中设置值？答案是使用std::future对象。每个std::promise对象都有一个关联的std::future对象，其他对象可以通过该对象获取promise设置的值。现在，线程1将把promiseObj传递给线程2。然后线程1将通过std::future的get函数获取线程2在std::promise中设置的值。

#include <iostream>
#include <thread>
#include <future>

void initiazer(std::promise<int> * promObj){
    std::cout<<"Inside Thread"<<std::endl;
    promObj->set_value(35);
}

int main(){
    std::promise<int> promiseObj;
    std::future<int> futureObj = promiseObj.get_future();
    std::thread th(initiazer, &promiseObj);
    std::cout<<futureObj.get()<<std::endl;
    th.join();
    return 0;
}

此外，如果您希望线程在不同的时间点返回多个值，则只需在线程中传递多个std::promise对象，然后从关联的多个std::future对象中获取多个返回值。

1.5. thread_local

C++11中提供了thread_local，thread_local 定义的变量在每个线程都保存一份副本，而且互不干扰，在线程退出的时候自动销毁。

#include <iostream>
#include <thread>
#include <chrono>

thread_local int g_k = 0;

void func1(){
    while (true){
        ++g_k;
    }
}

void func2(){
    while (true){
        std::cout << "func2 thread ID is : " << std::this_thread::get_id() << std::endl;
        std::cout << "func2 g_k = " << g_k << std::endl;

        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

void main(){
    std::thread t1(func1);
    std::thread t2(func2);

    t1.join();
    t2.join();
}

在func1()对g_k循环加1操作，在func2()每个1000毫秒输出一次g_k的值：

func2 thread ID is : 15312
func2 g_k = 0
func2 thread ID is : 15312
func2 g_k = 0
func2 thread ID is : 15312
func2 g_k = 0

可以看出func2()中的g_k始终保持不变。

2. 同步 & 互斥

2.1. std::mutex

#include<mutex>
class Wallet
{
    int mMoney;
    std::mutex mutex;
public:
    Wallet() :mMoney(0) {}
    int getMoney() { return mMoney; }
    void addMoney(int money)
    {
        mutex.lock();  // 加锁
        for (int i = 0; i < money; ++i)
        {
            mMoney++;
        }
        mutex.unlock();  // 解锁
    }
};

lock()

调用线程将锁住该互斥量。

线程调用该函数会发生下面 3 种情况：
1. 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁。
2. 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住。
3. 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。
try_lock()

尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞。

线程调用该函数也会出现下面 3 种情况：
1. 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock 释放互斥量。
2. 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉。
3. 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

2.1.1. std::lock_guard

但是，如果我们忘记在功能结束时解锁互斥锁，该怎么办？在这种情况下，一个线程将退出而不释放锁，而其他线程将保持等待状态。如果锁定互斥锁后发生某些异常，则可能发生这种情况。为了避免这种情况，我们应该使用 std::lock_guard 。

Lock_Guard是一个类模板，它实现了互斥锁的RAII。它将互斥体包装在其对象中，并将附加的互斥体锁定在其构造函数中。当调用它的析构函数时，它会释放互斥锁。

void addMoney(int money){
    // 在构造函数中，它锁定互斥锁 In constructor it locks the mutex
    std::lock_guard<std::mutex> lockGuard(mutex);
    for (int i = 0; i < money; ++i){
        // 如果在此位置发生异常，则由于堆栈展开，将调用lockGuard的析构函数。
        mMoney++;
    }
    //一旦函数退出，则析构函数，将调用析构函数中的lockGuard对象，它解锁互斥锁。
}

值得注意的是，lock_guard 对象并不负责管理 Mutex 对象的生命周期，lock_guard 对象只是简化了 Mutex 对象的上锁和解锁操作，方便线程对互斥量上锁，即在某个 lock_guard 对象的声明周期内，它所管理的锁对象会一直保持上锁状态；而 lock_guard 的生命周期结束之后，它所管理的锁对象会被解锁。

#include <list>
#include <mutex>
#include <algorithm>

std::list<int> some_list; // 1
std::mutex some_mutex; // 2

void add_to_list(int new_value){
    std::lock_guard<std::mutex> guard(some_mutex); // 3
    some_list.push_back(new_value);
}

bool list_contains(int value_to_find){
    std::lock_guard<std::mutex> guard(some_mutex); // 4
    return std::find(some_list.begin(),some_list.end(),value_to_find) != some_list.end();
}

在大多数情况下，互斥量通常会与保护的数据放在同一个类中，而不是定义成全局变量。这是面向对象设计的准则：将其放在一个类中，就可让他们联系在一起，也可对类的功能进行封装，并进行数据保护。

2.1.2. std::unique_lock

但是 lock_guard 最大的缺点也是简单，没有给程序员提供足够的灵活度，因此，C++11 标准中定义了另外一个与 Mutex RAII 相关类 unique_lock，该类与 lock_guard 类相似，也很方便线程对互斥量上锁，但它提供了更好的上锁和解锁控制。

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::lock, std::unique_lock
// std::adopt_lock, std::defer_lock
std::mutex foo, bar;

void task_a() {
     std::lock(foo, bar);         // simultaneous lock (prevents deadlock)
     std::unique_lock<std::mutex> lck1(foo, std::adopt_lock);
     std::unique_lock<std::mutex> lck2(bar, std::adopt_lock);
     std::cout << "task a\n";
     // (unlocked automatically on destruction of lck1 and lck2)
}

void task_b() {
     // foo.lock(); bar.lock(); // replaced by:
     std::unique_lock<std::mutex> lck1, lck2;
     lck1 = std::unique_lock<std::mutex>(bar, std::defer_lock);
     lck2 = std::unique_lock<std::mutex>(foo, std::defer_lock);
     std::lock(lck1, lck2);       // simultaneous lock (prevents deadlock)
     std::cout << "task b\n";
     // (unlocked automatically on destruction of lck1 and lck2)
}

void main() {
     std::thread th1(task_a);
     std::thread th2(task_b);

     th1.join();
     th2.join();
}

2.1.3. 4种互斥量：递归/超时

在C++11中提供了4种互斥量。

std::mutex;                  //非递归的互斥量
std::timed_mutex;            //带超时的非递归互斥量
std::recursive_mutex;        //递归互斥量
std::recursive_timed_mutex;  //带超时的递归互斥量

2.2. 条件变量

将布尔全局变量设为默认值false。在线程2中将其值设置为true，线程1将继续在循环中检查其值，并且一旦变为true，线程1将继续处理数据。但是由于它是两个线程共享的全局变量，因此需要与互斥锁同步。让我们看看它的代码。

#include<iostream>
#include<thread>
#include<mutex>

class Application{
    std::mutex m_mutex;
    bool m_bDataLoaded;
public:
    Application(){
        m_bDataLoaded = false;
    }

    void loadData(){
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        std::cout << "Loading Data from XML" << std::endl;
        std::lock_guard<std::mutex> guard(m_mutex);
        m_bDataLoaded = true;
    }

    void mainTask(){
        std::cout << "Do Some Handshaking" << std::endl;
        m_mutex.lock();
        // 检查数据是否被加载
        while (m_bDataLoaded != true){
            m_mutex.unlock();
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            m_mutex.lock();
        }
        m_mutex.unlock();
        std::cout << "Do Processing On loaded Data" << std::endl;
    }
};

int main(){
    Application app;
    std::thread thread_1(&Application::mainTask, &app);
    std::thread thread_2(&Application::loadData, &app);
    thread_2.join();
    thread_1.join();
    return 0;
}

这种方式具有以下缺点：线程将继续获取该锁并释放它只是为了检查该值，因此它将消耗CPU周期，并使线程1变慢，因为它需要获取相同的锁来更新bool标志。因此，我们需要一种更好的机制来实现这一目标，例如，如果某种程度上线程1可以通过等待某个事件被发出信号而阻塞，而另一个线程可以通过该信号发出该事件并使线程1继续运行，则该机制就可以实现。这样可以节省许多CPU周期并提供更好的性能。

我们可以使用条件变量来实现。条件变量是一种事件，用于在2个线程之间发信号。一个线程可以等待它发出信号，而另一个线程可以发出信号。

条件变量是一种事件，用于在两个或多个线程之间发出信号。一个或多个线程可以等待它发出信号，而另一个线程可以发出信号。

wait():

该函数使当前线程阻塞，直到信号通知条件变量或发生虚假唤醒为止。它自动释放附加的互斥锁，阻塞当前线程，并将其添加到等待当前条件变量对象的线程列表中。
notify_one():

如果有任何线程在同一条件变量对象上等待，则notify_one解除阻塞其中一个等待线程。
notify_all():

如果有任何线程在相同的条件变量对象上等待，则notify_all解除所有等待线程的阻塞。

#include <iostream>
#include <thread>
#include <functional>
#include <mutex>
#include <condition_variable>

using namespace std::placeholders;

class Application{
    std::mutex m_mutex;
    std::condition_variable m_condVar;
    bool m_bDataLoaded;
public:
    Application(){
        m_bDataLoaded = false;
    }

    void loadData(){
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        std::cout << "Loading Data from XML" << std::endl;
        std::lock_guard<std::mutex> guard(m_mutex);
        m_bDataLoaded = true;
        m_condVar.notify_one();  // 通知变量
    }

    bool isDataLoaded(){
        return m_bDataLoaded;
    }

    void mainTask(){
        std::cout << "Do Some Handshaking" << std::endl;
        std::unique_lock<std::mutex> mlock(m_mutex);
        // 开始等待条件变量收到信号，wait()将在内部释放锁并使线程阻塞，一旦条件变量得到信号，就恢复线程并再次获得锁。
        //  然后检查是否满足条件，如果条件满足，则继续，否则继续等待。
        m_condVar.wait(mlock, std::bind(&Application::isDataLoaded, this));
        std::cout << "Do Processing On loaded Data" << std::endl;
    }
};

int main(){
    Application app;
    std::thread thread_1(&Application::mainTask, &app);
    std::thread thread_2(&Application::loadData, &app);
    thread_2.join();
    thread_1.join();
    return 0;
}

2.3. 信号量

3. std::async()

async教程和示例

这篇关于C++ std::thread 多线程的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

C/C++教程