C++11并发编程:多线程std::thread

让我来详细讲解一下C++11并发编程:多线程std::thread的完整攻略。

标题

C++11并发编程:多线程std::thread

正文

C++11引入了新的线程库，包括std::thread、std::mutex、std::condition_variable 和 std::atomic等等。其中，std::thread是用于创建和管理线程的库。下面将详细介绍如何使用std::thread进行多线程编程。

创建线程

在C++11之前，创建线程是很繁琐的，并且充满了陷阱。C++11之后，创建线程变得非常的简单。使用std::thread创建一个新的线程只需要以下几步：

1. 定义一个函数，这个函数是新线程的入口点。
2. 创建std::thread对象，并将该函数作为参数传递给它。
3. 运行线程。
4. 等待线程完成运行。

#include <iostream>
#include <thread>

//新线程的入口点
void printMessage(std::string message)
{
    std::cout << message << std::endl;
}

int main()
{
    //创建一个新线程并运行它
    std::thread t(printMessage, "Hello from new thread!");

    //等待新线程完成运行
    t.join();

    return 0;
}

通过上面的示例代码，我们可以看到，使用std::thread创建新线程非常简单，只需要传递一个函数作为参数以及其他可选参数，就可以创建一个新线程。

传递参数

当创建一个新的线程时，可以将函数的参数一并传递给它。在上面的示例代码中，我们通过将“Hello from new thread!”传递给printMessage函数来传递参数。

#include <iostream>
#include <thread>

void printMessage(std::string message)
{
    std::cout << message << std::endl;
}

int main()
{
    std::string message("Hello from main thread!");

    //创建一个新线程，并传递参数
    std::thread t(printMessage, message);

    t.join();

    return 0;
}

获取线程ID

std::thread对象提供了一个成员函数，用于获取线程ID。该函数是std::thread::get_id()，它返回一个std::thread::id类型的值。

#include <iostream>
#include <thread>

void printMessage()
{
    std::cout << "Thread ID = " << std::this_thread::get_id() << std::endl;
}

int main()
{
    std::thread t(printMessage);

    std::cout << "Main thread ID = " << std::this_thread::get_id() << std::endl;

    t.join();

    return 0;
}

上面的例子创建了一个新线程并输出其ID，同时也输出了主线程的ID。

线程同步

当多个线程同时访问同一个变量时，可能会发生冲突和竞争条件。C++11中提供了一些机制来解决这些问题。

互斥锁

互斥锁是一种保护共享资源的机制，它保证只有一个线程访问共享资源。当一个线程获得了互斥锁，其他线程就不能访问这个共享资源，直到该线程释放锁为止。C++11提供了std::mutex类来实现互斥锁。

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

std::mutex mtx;

void printMessage(std::string message)
{
    std::lock_guard<std::mutex> lock(mtx); //获取互斥锁

    std::cout << message << std::endl;
}

int main()
{
    std::thread t1(printMessage, "Hello from thread1!");
    std::thread t2(printMessage, "Hello from thread2!");

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

    return 0;
}

上面的代码创建了两个新线程，并在printMessage函数中使用了std::mutex来保护共享资源。这样就能确保每次只有一个线程访问std::cout。

条件变量

条件变量是一种在多个线程之间进行通信的机制。它可以使一个线程等待另一个线程的通知，从而避免不必要的资源消耗。C++11提供了std::condition_variable类来实现条件变量。

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

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void printMessage(std::string message)
{
    std::unique_lock<std::mutex> lock(mtx);

    //等待条件变量通知
    while (!ready)
    {
        cv.wait(lock);
    }

    std::cout << message << std::endl;
}

void setReady()
{
    std::unique_lock<std::mutex> lock(mtx);
    ready = true;
    cv.notify_all(); //通知所有等待条件变量的线程
}

int main()
{
    std::thread t1(printMessage, "Hello from thread1!");
    std::thread t2(printMessage, "Hello from thread2!");

    std::this_thread::sleep_for(std::chrono::seconds(2)); //休眠2秒

    setReady(); //设置条件变量

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

    return 0;
}

上面的代码创建了两个新线程，它们都等待条件变量的通知。在主线程中休眠2秒后，调用setReady函数设置ready变量为true，并通知所有等待条件变量的线程。这时两个新线程都可以继续执行printMessage函数。

结论

通过上述例子，我们可以看到，使用C++11的std::thread库实现多线程编程是非常的简单。同时，标准库中提供的互斥锁、条件变量等机制，可以很好地解决多线程编程中的同步问题。