在C++11之前，C++并没有提供原生的并发支持。开发者通常需要依赖于操作系统的API（如Windows的CreateThread或POSIX的pthread_create）或者第三方库（如Boost.Thread）来创建和管理线程。这些方式存在以下几个问题：

1. 平台依赖：不同的操作系统提供了不同的线程API，这意味着你需要为每个目标平台编写不同的代码，或者使用预处理器宏来处理平台差异。这会使代码变得复杂和难以维护。

2. 错误处理困难：操作系统的线程API通常通过返回错误码来报告错误，这需要你在每次调用API后检查错误码，并手动处理错误。这不仅繁琐，而且容易出错。

3. 缺乏高级特性：操作系统的线程API通常只提供了基础的线程创建和同步功能，缺乏一些高级特性，如线程池、future和promise等。

相比之下，C++11的并发库提供了以下优势：

1. 平台无关：C++11的并发库是C++标准的一部分，这意味着你可以在任何支持C++11的编译器上使用它，无需考虑平台差异。

2. 异常安全：C++11的并发库使用异常来报告错误，这使得错误处理更加简单和安全。例如，如果你试图在已经启动的线程上调用std::thread::join，C++11会抛出一个std::system_error异常。

3. 高级特性：C++11的并发库提供了一些高级特性，如std::async、std::future和std::promise等，这些特性使得并发编程更加方便和强大。

这些工具使得C++程序员可以更方便、更安全地编写多线程代码。下面我们将详细介绍这些并发工具的使用。

1. 线程（std::thread）

C++11的std::thread类提供了对操作系统原生线程的封装。你可以通过创建std::thread对象来创建新的线程，并通过成员函数join()或detach()来等待线程结束或让线程在后台运行。

#include <iostream>
#include <thread>

void hello() {
    std::cout << "Hello, concurrent world\n";
}

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

在这个例子中，我们创建了一个新的线程来运行hello函数，并在主线程中通过join()等待新线程结束。

2. 互斥量（std::mutex）

C++11的std::mutex类提供了对操作系统原生互斥量的封装。你可以使用互斥量来保护共享数据，防止多个线程同时访问。

#include <mutex>
#include <thread>

std::mutex mtx;  // 全局互斥量

void print_block(int n, char c) {
    mtx.lock();
    for (int i=0; i<n; ++i) { std::cout << c; }
    std::cout << '\n';
    mtx.unlock();
}

int main() {
    std::thread th1(print_block,50,'*');
    std::thread th2(print_block,50,'$');

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

    return 0;
}

在这个例子中，我们使用互斥量mtx来保护std::cout，防止两个线程同时输出。

3. 条件变量（std::condition_variable）

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 print_id(int id) {
    std::unique_lock<std::mutex> lck(mtx);
    while (!ready) cv.wait(lck);
    std::cout << "thread " << id << '\n';
}

void go() {
    std::unique_lock<std::mutex> lck(mtx);
    ready = true;
    cv.notify_all();
}

int main() {
    std::thread threads[10];
    for (int i=0; i<10; ++i)
        threads[i] = std::thread(print_id,i);

    std::cout << "10 threads ready to race...\n";
    go();

    for (auto& th : threads) th.join();

    return 0;
}

在这个例子中，我们使用条件变量cv来实现10个线程的同步。当go函数被调用时，所有等待在cv上的线程都会被唤醒。

4. Future（std::future）

C++11的std::future类提供了一种表示异步操作结果的方式。你可以使用std::async函数来启动一个异步操作，并返回一个std::future对象。然后你可以在任何时候通过std::future::get函数来获取异步操作的结果。

#include <iostream>
#include <future>

int factorial(int n) {
    int res = 1;
    for(int i = n; i > 1; --i)
        res *= i;
    return res;
}

int main() {
    std::future<int> fut = std::async(factorial, 5);
    std::cout << "Factorial of 5 is " << fut.get() << std::endl;
    return 0;
}

在这个例子中，我们使用std::async启动了一个异步操作来计算5的阶乘，并通过std::future::get获取了结果。