C++线程之thread详解

简介

线程是现代程序设计中最重要和有用的概念之一，是使程序在同时执行多个任务的机制。C++语言提供了标准库中的thread类，使得在C++中创建线程非常简单。本文将对thread的用法进行详细的讲解和说明，包括如何创建和管理线程、如何进行线程同步等内容。

创建线程

C++线程库提供了std::thread类用于创建和管理线程。创建线程的最基本方式是提供一个函数，并将其作为参数传递给std::thread构造函数。例如，下面的代码中，我们创建了一个只输出一句话的线程：

#include <iostream>
#include <thread>

void my_thread_function(){
    std::cout << "Hello from my thread!" << std::endl;
}

int main(){
    std::thread my_thread(my_thread_function);
    my_thread.join();
    return 0;
}

在上面的代码中，我们创建了一个名为my_thread_function的函数，并将其作为参数传递给了std::thread类的构造函数。然后，我们通过调用join等待线程执行完毕，然后退出程序。运行上述代码，输出结果为：

Hello from my thread!

可以看到线程已经成功地执行了，输出了我们期望的结果。当std::thread对象被销毁时，它会自动调用join方法等待线程执行完成。

线程同步

在多线程应用程序中，同步是一个非常重要的问题。如果没有有效的同步，可能会出现数据竞争、死锁等问题。C++线程库为我们提供了一些同步机制，例如互斥锁和条件变量。

互斥锁

互斥锁是一种同步机制，常用于保护临界区代码，以确保同一时间只有一个线程可以访问该代码块。C++线程库中提供了std::mutex类用于实现互斥锁。

下面的示例代码中，我们通过定义互斥锁来保护global_variable变量的访问。

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

std::mutex my_mutex;
int global_variable = 0;

void my_thread_function(){
    for(int i = 0; i < 10; ++i){
        my_mutex.lock();
        ++global_variable;
        my_mutex.unlock();
    }
}

int main(){
    std::thread my_thread1(my_thread_function);
    std::thread my_thread2(my_thread_function);

    my_thread1.join();
    my_thread2.join();

    std::cout << "global_variable is " << global_variable << std::endl;

    return 0;
}

在上面的代码中，我们创建了两个线程，两个线程都会对global_variable变量进行操作，因此，我们需要对它进行保护。我们使用std::mutex类来定义互斥锁，并在操作之前调用lock方法来获取锁，操作完成后调用unlock方法释放锁。运行上述代码，输出结果为：

global_variable is 20

可以看到，最终global_variable的值为20，证明了两个线程都可以正确地访问并更新该变量。

条件变量

条件变量是一种同步机制，允许线程等待特定条件的满足。C++线程库中提供了std::condition_variable类用于实现条件变量。

下面的示例代码中，我们使用std::condition_variable来实现一个简单的生产者-消费者模型。

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

std::queue<int> my_queue;
std::mutex my_mutex;
std::condition_variable my_cv;

void producer_thread_function(){
    for(int i = 0; i < 10; ++i){
        std::unique_lock<std::mutex> lock(my_mutex);
        my_queue.push(i);
        lock.unlock();
        my_cv.notify_one();
    }
}

void consumer_thread_function(){
    while(true){
        std::unique_lock<std::mutex> lock(my_mutex);
        my_cv.wait(lock, []{ return !my_queue.empty(); });
        int data = my_queue.front();       
        my_queue.pop();
        lock.unlock();
        std::cout << "Consumed: " << data << std::endl;
        if(data == 9) break;
    }
}

int main(){
    std::thread producer_thread(producer_thread_function);
    std::thread consumer_thread(consumer_thread_function);

    producer_thread.join();
    consumer_thread.join();

    return 0;
}

在上面的代码中，我们创建了两个线程，producer_thread_function线程负责生产数据，consumer_thread_function线程负责消费数据。我们使用std::queue保存数据，并与std::mutex和std::condition_variable一起使用，以实现线程的同步和等待。

具体来说，我们在生产者线程中使用unique_lock获取锁，并使用my_cv.notify_one()通知消费者线程有新的数据需要消费。在消费者线程中，我们首先使用my_cv.wait()方法来等待有新的数据可以消费。同时，我们定义了一个lambda表达式作为wait方法的第二个参数，以在等待期间检查队列是否为空。当wait方法返回后，我们使用my_queue.pop()将数据从队列中消费，并使用lock.unlock()释放锁。

运行上述代码，输出结果为：

Consumed: 0
Consumed: 1
Consumed: 2
Consumed: 3
Consumed: 4
Consumed: 5
Consumed: 6
Consumed: 7
Consumed: 8
Consumed: 9

可以看到，数据正确地被生产和消费，证明了我们实现了一个简单的生产者-消费者模型。

结论

以上是对C++线程库中std::thread类的详细介绍和说明。通过本文，我们可以了解到如何使用std::thread类创建和管理线程、如何使用互斥锁和条件变量进行线程同步等内容。希望读者可以通过本文对C++多线程编程有更深入的了解和认识。