C++ 如何实现多线程与线程同步

C++多线程与线程同步是一个重要的话题。在C++中，使用标准库提供的thread和mutex类可以轻松实现多线程和线程同步。

实现多线程

使用std::thread类

在C++11中，引入了std::thread类来实现多线程。std::thread类是一个轻量级的类，它允许我们轻松地启动一个新线程。

创建一个新线程需要执行以下步骤：

1. 创建一个std::thread对象，将一个函数指针作为构造函数参数传递。

2. 调用std::thread对象的join()函数，等待该线程执行完毕。

下面是一个简单的示例代码，它启动了一个新线程并输出一些消息：

#include <iostream>
#include <thread>

void myFunction()
{
    std::cout << "Hello from myFunction!" << std::endl;
}

int main()
{
    std::thread t(myFunction);  //创建新线程
    t.join();  //等待线程执行完毕
    std::cout << "Hello from main!" << std::endl;
    return 0;
}

使用lambda表达式简化代码

可以使用lambda表达式来简化代码。lambda表达式是一个匿名函数。它可以将函数的定义与函数的调用紧密地结合在一起。下面是一个使用lambda表达式的例子：

#include <iostream>
#include <thread>

int main()
{
    std::thread t([](){
        std::cout << "Hello from thread!" << std::endl;
    });
    t.join();
    std::cout << "Hello from main!" << std::endl;
    return 0;
}

在lambda表达式中，我们定义了一个函数，然后立即将其作为std::thread类的构造函数参数传递，从而启动一个新线程。

线程同步

使用std::mutex类

简单的多线程程序很容易出现竞态条件（race condition）。竞态条件会导致程序输出的结果不确定或不正确。我们需要使用线程同步来避免这些问题。

std::mutex类是一个互斥量，用于保护共享数据结构。std::mutex类提供了两个方法：lock()和unlock()，用于在访问共享数据结构之前加锁并在访问完成后解锁。

下面是一个示例，用std::mutex类保护共享数据结构：

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

std::mutex g_mutex;  //定义互斥量

void myFunction(int id)
{
    g_mutex.lock();  //加锁
    std::cout << "Thread " << id << " is working" << std::endl;
    g_mutex.unlock();  //解锁
}

int main()
{
    std::thread t1(myFunction, 1);
    std::thread t2(myFunction, 2);
    t1.join();
    t2.join();
    return 0;
}

在上面的示例代码中，std::mutex类用于保护共享的输出语句。myFunction()函数在输出语句之前调用g_mutex.lock()方法来加锁，然后在输出语句之后调用g_mutex.unlock()来解锁。

使用std::lock_guard类

使用std::lock_guard类可以更方便地保护共享数据结构。

std::lock_guard类是一个轻量级类，用于自动管理互斥量的锁定和解锁。在std::lock_guard对象的生命周期内，互斥量锁是被锁定的。当std::lock_guard对象销毁时，互斥量会被自动解锁。

下面是一个示例，用std::lock_guard类保护共享数据结构：

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

std::mutex g_mutex;  //定义互斥量

void myFunction(int id)
{
    std::lock_guard<std::mutex> lock(g_mutex);  //定义std::lock_guard对象
    std::cout << "Thread " << id << " is working" << std::endl;
}

int main()
{
    std::thread t1(myFunction, 1);
    std::thread t2(myFunction, 2);
    t1.join();
    t2.join();
    return 0;
}

在上面的代码中，std::lock_guard对象被定义在myFunction()函数的内部，它保护了共享的输出语句。当std::lock_guard对象销毁时，互斥量会被自动解锁。

总结

本篇文章讲解了如何在C++中实现多线程和线程同步。通过使用std::thread类，我们可以轻松地启动和管理多个线程。std::mutex类和std::lock_guard类则使我们可以安全地访问共享数据结构，避免了竞态条件和死锁问题的产生。