深入理解C++11线程库

# 1. C++11线程库概述

## 1.1 C++11线程库的背景
C++11引入了全新的线程库，以支持多线程编程，这是继C++98/03标准后的一大进步。它为开发者提供了更高层次的抽象，简化了多线程应用的开发，并且解决了以往跨平台和资源管理等难题。

## 1.2 C++11线程库的目的
C++11线程库旨在为C++语言提供标准的、易于使用的多线程编程接口，使得开发者能够更加方便地实现并发程序设计。通过标准库的统一，也推动了平台间的兼容性。

## 1.3 C++11线程库的应用场景
在多核处理器普及的今天，多线程编程已成为提高程序性能的重要手段。C++11线程库适用于需要高性能计算、并行数据处理、以及复杂的实时系统等场景。

#include <iostream>
#include <thread>

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

int main() {
    std::thread t(printHello);
    t.join();
    return 0;
}

上述代码是使用C++11线程库创建并启动一个线程的简单示例。通过引入`<thread>`头文件，并使用`std::thread`类，可以方便地管理线程的生命周期。

# 2. C++11线程库的基础理论

### 2.1 线程库的基本概念

#### 2.1.1 什么是线程和进程

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个进程中可以有多个线程，每个线程都是系统独立分配和调度的基本单位，系统在运行时会为每个线程分配不同的CPU时间片。

进程则是一个正在执行中的程序实例。每个进程都拥有自己独立的内存空间，系统资源的分配是按进程进行的。进程中的线程共享进程的内存空间和系统资源，但彼此是独立执行的。

#### 2.1.2 线程和进程的区别

在操作系统中，线程与进程之间有诸多区别，最本质的差别在于：

- 资源：进程拥有自己独立的地址空间和系统资源，而线程共享所属进程的资源。
- 切换开销：线程之间的上下文切换比进程要轻量得多，因为它不需要切换进程的内存空间。
- 并发度：由于线程之间共享资源，相比于进程，线程间通信更加简单高效，更适合实现多线程并发执行。
- 独立性：每个进程都有自己的生命周期，而线程是依赖于进程存在的。

### 2.2 C++11线程库的组成

#### 2.2.1 线程库的主要组件

C++11引入了一个新的线程库，它主要包括以下几个组件：

- `std::thread`：用于创建和管理线程。
- `std::mutex`、`std::lock_guard`、`std::unique_lock`：用于线程同步，防止数据竞争。
- `std::condition_variable`：用于线程间通信和同步。
- `std::async`、`std::future`、`std::promise`：用于启动异步任务，并获取异步操作的结果。

#### 2.2.2 线程库与其他库的关系

C++11线程库的引入，使得C++语言能够直接操作底层线程，不再依赖于平台特定的API如 POSIX threads (pthreads) 或 Windows threads。它还提供了与C++标准库其他组件（如算法和容器）的无缝集成，支持更多高级并发编程模式。

### 2.3 C++11线程库的优势

#### 2.3.1 新增的线程功能

C++11线程库相比于之前的一些跨平台线程库（如Boost.Thread），提供了以下功能上的优势：

- 友好的API：C++11线程库设计了一套现代的C++风格的接口，易于理解和使用。
- 可移植性：由于是标准库的一部分，它提供了平台无关的接口。
- 内存模型：提供了新的内存模型和原子操作库，这对于多线程环境下的内存访问至关重要。
- 异步操作：通过`std::async`，可以更简单地发起异步任务，并通过`std::future`获取结果。

#### 2.3.2 线程库在性能上的提升

性能上的提升主要体现在：

- 更高效的线程创建和管理：减少线程创建和销毁的开销，提供更灵活的线程控制能力。
- 改进的同步机制：提供了一套简单且强健的锁机制，可以有效减少死锁的发生概率。
- 高级并发组件：例如`std::async`和`std::future`使得异步编程更加容易，且对错误处理进行了简化。

# 3. C++11线程库的编程实践

## 3.1 线程的创建和管理

### 3.1.1 如何创建线程

在C++11中，线程的创建是通过`std::thread`类来完成的。首先需要包含头文件`<thread>`，然后可以使用`std::thread`的构造函数创建线程。构造函数可以接收一个函数和一系列参数，这些参数将被传递给该函数。下面是一个简单的线程创建示例：

#include <iostream>
#include <thread>

void print_number(int num) {
    std::cout << "number: " << num << std::endl;
}

int main() {
    std::thread t(print_number, 10);
    t.join();  // 等待线程完成
    return 0;
}

在上面的代码中，我们定义了一个`print_number`函数，它将接收一个整数参数并打印它。然后在`main`函数中，我们创建了一个名为`t`的线程，它将执行`print_number`函数，并将整数10作为参数传递给它。通过调用`t.join()`，主线程会等待`t`线程完成其工作。

### 3.1.2 线程的同步和互斥

创建线程后，我们可能需要确保线程之间能够安全地共享资源。C++11提供了一系列同步机制，包括互斥锁(`std::mutex`)、锁(`std::lock_guard`和`std::unique_lock`)、条件变量(`std::condition_variable`)等。

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

std::mutex mtx;

void print_even(int n) {
    for (int i = 0; i < n; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        if (i % 2 == 0) {
            std::cout << i << " ";
        }
    }
}

void print_odd(int n) {
    for (int i = 0; i < n; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        if (i % 2 != 0) {
            std::cout << i << " ";
        }
    }
}

int main() {
    std::thread t1(print_even, 100);
    std::thread t2(print_odd, 100);
    t1.join();
    t2.join();
    return 0;
}

在这个例子中，两个线程分别打印偶数和奇数。为了防止输出交错，使用了`std::mutex`来确保同一时间只有一个线程能够访问`std::cout`。`std::lock_guard`是一个RAII风格的锁管理对象，它在构造时自动锁定互斥量，并在析构时自动释放锁。这确保了即使在异常发生时，锁也会被正确释放，避免了死锁的风险。

### 3.2 线程的高级操作

#### 3.2.1 线程池的实现

线程池是一种多线程处理形式，用于管理多个工作线程。线程池主要由任务队列、线程集合和同步机制三部分组成。以下是实现简单线程池的示例代码：

#include <iostream>
#include <queue>
#include <vector>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <future>

class ThreadPool {
public:
    ThreadPool(size_t);
    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::result_of<F(Args...)>::type>;
    ~ThreadPool();

private:
    // 需要跟踪线程和任务
    std::vector< std::thread > workers;
    std::queue< std::function<void()> > tasks;
    // 同步
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

// 构造函数启动一定数量的工作线程
ThreadPool::ThreadPool(size_t threads)
    :   stop(false)
{
    for(size_t i = 0;i<threads;++i)
        workers.emplace_back(
            [this]
            {
                for(;;)
                {
                    std::function<void()> task;

                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        this->condition.wait(lock,
                            [this]{ return this->stop || !this->tasks.empty(); });
                        if(this->stop && this->tasks.empty())
                            return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }

                    task();
                }
            }
        );
}

// 添加新的工作项到线程池中
template<class F, class... Args>
auto ThreadPool::enqueue(F&& f, Args&&... args) 
    -> std::future<typename std::result_of<F(Args...)>::type>
{
    using return_type = typename std::result_of<F(Args...)>::type;

    auto task = std::make_shared< std::packaged_task<return_type()> >(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
    std::future<return_type> res = task->get_future();
    {
        std::unique_lock<std::mutex> lock(queue_mutex);

        // 不允许在停止的线程池中加入新的任务
        if(stop)
            throw std::runtime_error("enqueue on stopped ThreadPool");

        tasks.emplace([task](){ (*task)(); });
    }
    condition.notify_one();
    return res;
}

// 析构函数结束所有线程
ThreadPool::~ThreadPool()
{
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop = true;
    }
    condition.notify_all();
    for(std::thread &worker: workers)
        worker.join();
}

这段代码展示了一个简单的线程池实现。它使用任务队列存储待处理的工作，并通过`std::thread`启动多个工作线程。每个工作线程会等待并执行队列中的任务。通过`enqueue`方法，用户可以向线程池提交新的任务。

#### 3.2.2 线程的优先级调整

调整线程优先级可以确保更关键的任务获得更多的处理资源。在C++11中，可以使用`std::thread::native_handle`获取操作系统的原生线程句柄，并用它来设置优先级。以下是一个跨平台设置线程优先级的示例：

#include <thread>
#ifdef _WIN32
#include <windows.h>
#else
#include <sys/resource.h>
#endif

void set_thread_priority(std::thread& t, int priority) {
#ifdef _WIN32
    // Windows平台的设置代码
    SetThreadPriority(t.native_handle(), priority);
#else
    // POSIX平台的设置代码
    struct sched_param param;
    int max_priority = sched_get_priority_max(SCHED_RR);
    int min_priority = sched_get_priority_min(SCHED_RR);
    int priority_range = max_priority - min_priority;

    param.sched_priority = (max_priority - ((priority_range * priority) / 100));
    pthread_setschedparam(t.native_handle(), SCHED_RR, &param);
#endif
}

在使用此函数之前，需要包含正确的平台特定头文件，并且确保在调用时具有必要的权限，因为修改线程优先级可能需要特定的系统权限。

### 3.3 线程的异常处理

#### 3.3.1 线程的异常类型

C++11中的线程库提供了对异常处理的支持。线程可以抛出异常，并由创建它的线程捕获。异常处理通常在调用线程的`join()`或`detach()`方法时进行。如果线程在`join()`之前结束，它的异常会存储在与线程关联的`std::promise`对象中，并在`join()`被调用时重新抛出。

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

void throw_exception() {
    throw std::runtime_error("thread exception");
}

int main() {
    std::future<void> fut = std::async(std::launch::async, throw_exception);
    try {
        fut.get();
    } catch(const std::exception& e) {
        std::cerr << "caught exception: " << e.what() << std::endl;
    }
    return 0;
}

在上述代码中，`throw_exception`函数抛出一个异常，然后通过`std::async`启动的线程将捕获这个异常，并在`main`函数的`try`块中重新抛出。

#### 3.3.2 异常捕获和处理的方法

当多个线程并发执行时，错误处理变得更加复杂。理想的做法是在每个线程中独立处理异常，但有时需要跨线程传播错误。一个常见的策略是在每个线程中捕获和处理异常，但在主线程中统一处理。

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

void thread_func(std::promise<int>& prom) {
    try {
        // ... some operations
        throw std::runtime_error("exception in thread");
    } catch(...) {
        prom.set_exception(std::current_exception());
    }
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();
    std::thread t(thread_func, std::ref(prom));
    t.detach(); // 分离线程，允许它独立运行

    try {
        fut.get(); // 等待线程完成并获取结果或异常
    } catch(const std::exception& e) {
        std::cerr << "caught exception from thread: " << e.what() << std::endl;
    }

    return 0;
}

在这段代码中，`thread_func`函数在捕获异常后使用`std::promise`来设置异常。主线程通过调用`fut.get()`来等待并处理来自线程的异常。使用`std::async`和`std::launch::async`可以简化此过程，但`std::thread`允许更灵活的错误处理策略。

# 4. C++11线程库的深入应用

在C++11中，对线程和并发的处理引入了诸多新的特性，使得开发者能够更加方便和高效地编写多线程程序。本章节将深入探讨并发容器和同步机制、原子操作与内存模型、并发算法和任务的实现与应用。

## 4.1 并发容器和同步机制

并发编程的一个关键挑战是管理共享资源。C++11引入了多种并发容器和同步机制，以解决多线程环境中的数据竞争和同步问题。

### 4.1.1 并发容器的使用和特点

并发容器是为并发环境设计的数据结构，能够支持无锁或低锁操作，减少线程间的阻塞，提高性能。C++11标准库中提供了几种并发容器，包括`std::unordered_map`、`std::unordered_set`、`std::vector`等，这些容器在多线程环境下可以直接使用，但它们内部的元素操作并不保证线程安全。

#include <iostream>
#include <thread>
#include <unordered_map>

std::unordered_map<int, std::string> concurrentMap;

void insertData(int key, std::string value) {
    concurrentMap[key] = value;
}

void fetchData(int key) {
    if (concurrentMap.find(key) != concurrentMap.end()) {
        std::cout << "Key: " << key << " Value: " << concurrentMap[key] << std::endl;
    } else {
        std::cout << "Key not found!" << std::endl;
    }
}

int main() {
    std::thread t1(insertData, 1, "Value1");
    std::thread t2(fetchData, 1);

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

    return 0;
}

在上述代码示例中，我们创建了两个线程：一个用于向`std::unordered_map`中插入数据，另一个用于检索数据。由于`std::unordered_map`的元素操作本身不是线程安全的，因此在实际使用中需要额外的同步机制来保证线程安全，如使用`std::mutex`进行锁定。

### 4.1.2 同步机制的实现和选择

同步机制是多线程编程的核心，它确保线程间能够以可预测和同步的方式访问共享数据。C++11提供了多种同步工具，包括互斥锁（`std::mutex`）、条件变量（`std::condition_variable`）、原子操作和锁（`std::lock_guard`、`std::unique_lock`）等。

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

std::mutex mtx;
int sharedResource = 0;

void incrementResource() {
    for (int i = 0; i < 1000; ++i) {
        mtx.lock();
        ++sharedResource;
        mtx.unlock();
    }
}

void decrementResource() {
    for (int i = 0; i < 1000; ++i) {
        mtx.lock();
        --sharedResource;
        mtx.unlock();
    }
}

int main() {
    std::thread t1(incrementResource);
    std::thread t2(decrementResource);

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

    std::cout << "Final sharedResource value is " << sharedResource << std::endl;
    return 0;
}

在上面的代码示例中，我们创建了两个线程，分别用于增加和减少共享资源的值。通过使用`std::mutex`互斥锁来同步对共享资源的访问，以避免竞争条件和数据竞争的发生。

选择合适的同步机制对于设计高效且无死锁的并发程序至关重要。开发者应该根据具体的需求来决定使用互斥锁、读写锁（`std::shared_mutex`）、条件变量、原子操作等不同的同步工具。

## 4.2 原子操作与内存模型

在并发编程中，原子操作提供了最小的、不可分割的执行单元，使得线程在执行这些操作时不会被其他线程打断，从而避免并发问题。

### 4.2.1 原子操作的原理和应用

C++11通过`<atomic>`头文件提供了原子类型和函数，用于执行原子操作。原子操作保证了操作的原子性，这对于实现无锁数据结构和算法至关重要。

#include <iostream>
#include <atomic>
#include <thread>

std::atomic<int> atomicValue(0);

void incrementAtomicValue() {
    for (int i = 0; i < 1000; ++i) {
        atomicValue.fetch_add(1, std::memory_order_relaxed);
    }
}

int main() {
    std::thread t1(incrementAtomicValue);
    std::thread t2(incrementAtomicValue);

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

    std::cout << "Final atomicValue is " << atomicValue << std::endl;
    return 0;
}

在上述示例中，我们使用`std::atomic`来创建一个原子整数`atomicValue`，并提供了两个线程执行增加操作。由于`std::atomic`的操作保证了原子性，因此在多线程环境下，即使没有额外的同步机制，操作也是安全的。

### 4.2.2 内存模型的理解和运用

C++11引入了新的内存模型，定义了原子操作和普通操作如何在内存中排序，从而提供了对多线程程序行为的明确语义。

内存模型涉及的术语包括"原子操作"、"顺序一致性"、"内存序"和"内存屏障"等。例如，通过为`std::atomic`对象的成员函数指定不同的内存序参数（如`std::memory_order_acquire`、`std::memory_order_release`等），可以控制内存操作的排序，实现更细粒度的同步。

#include <iostream>
#include <atomic>

std::atomic<int> atomicFlag(0);
std::atomic<int> data(0);

void readerThread() {
    while (atomicFlag.load(std::memory_order_acquire) == 0) {
        // 等待数据被写入
    }
    std::cout << "Data: " << data << std::endl;
}

void writerThread() {
    data = 42; // 写入数据
    atomicFlag.store(1, std::memory_order_release); // 通知读取线程
}

int main() {
    std::thread t1(readerThread);
    std::thread t2(writerThread);

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

    return 0;
}

在本示例中，我们模拟了一个发布-订阅模式，其中`writerThread`线程写入数据，并通过`std::atomic`的原子操作来发布一个信号（`atomicFlag`）。`readerThread`线程等待信号，然后读取数据。通过指定合适的内存序参数，我们可以确保在没有显式锁的情况下，数据的发布和订阅是按照预期的顺序执行的。

## 4.3 并发算法和任务

C++11在并发算法和任务分解方面提供了新的抽象，使得并发编程更加接近于声明式编程范式，从而简化了并发程序的编写。

### 4.3.1 并发算法的设计思想

并发算法允许开发者将算法分解为可以并行执行的部分。C++11引入了一些并发算法，例如`std::for_each`、`std::copy`、`std::transform`等，这些算法都接受一个执行策略参数，允许用户指定算法如何在并行环境中执行。

### 4.3.2 任务的分解与调度策略

并发任务分解通常涉及将任务拆分为更小的子任务，并为每个子任务分配线程或线程池来执行。这种策略能够显著提高程序的吞吐量，尤其是在计算密集型任务中。

在C++11中，可以利用`std::async`和`std::future`来实现任务的异步执行。`std::async`启动一个异步任务并返回一个`std::future`对象，该对象可以用于获取异步执行的结果。

#include <iostream>
#include <future>
#include <chrono>

void task(int n) {
    std::this_thread::sleep_for(std::chrono::seconds(n));
    std::cout << "Task completed after " << n << " seconds" << std::endl;
}

int main() {
    std::future<void> task1 = std::async(std::launch::async, task, 1);
    std::future<void> task2 = std::async(std::launch::async, task, 2);

    task1.get();
    task2.get();

    return 0;
}

在示例代码中，我们启动了两个异步任务，每个任务分别休眠1秒和2秒。由于使用了`std::async`，这两个任务是并行执行的。`task1.get()`和`task2.get()`调用将会阻塞主线程，直到对应的任务完成。

通过合理地使用并发算法和任务，可以充分利用现代多核处理器的计算能力，为高效和响应式程序设计提供支持。在下一章节中，我们将通过具体的项目案例来展示如何在实际开发中应用C++11线程库。

# 5. C++11线程库在实际项目中的应用案例

在C++11标准被广泛接受后，现代C++程序设计越来越多地利用标准库中的线程库来处理并发和多线程问题。本章节将通过几个具体的案例，来分析和讨论C++11线程库在实际项目中的应用。

## 5.1 案例分析：多线程网络服务器

### 5.1.1 服务器的需求分析

多线程网络服务器是并发编程的一个典型应用。在高并发环境下，服务器需要能够接受和处理来自多个客户端的连接和请求，而不会造成服务端的性能瓶颈。常见的需求包括但不限于：

- 高效处理并发连接；
- 稳定且高效的请求处理；
- 安全的数据传输；
- 简单的扩展性和维护性。

### 5.1.2 多线程的设计和实现

在设计和实现多线程网络服务器时，C++11线程库可以提供强大的支持。下面是一个简单的代码示例，展示如何使用C++11的`thread`和`mutex`来创建一个简单的多线程服务器：

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <functional>
#include <boost/asio.hpp>

// 假设这是一个处理请求的函数
void handle_request(std::mutex& m, int& count) {
    std::lock_guard<std::mutex> lock(m);
    // 处理请求的代码
    ++count;
    std::cout << "处理请求，当前请求次数: " << count << std::endl;
}

int main() {
    boost::asio::io_context io_context;
    std::mutex m;
    int count = 0;

    // 创建多个线程来处理请求
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(handle_request, std::ref(m), std::ref(count));
    }

    // 在io_context中处理任务
    io_context.run();

    // 等待所有线程完成
    for (auto& t : threads) {
        if (t.joinable()) {
            t.join();
        }
    }

    return 0;
}

在这个示例中，`handle_request`函数模拟了处理请求的操作，它利用互斥锁`mutex`来保证资源的安全访问。`main`函数中创建了多个线程来模拟服务器的并发处理能力。使用`boost::asio`库是因为它提供了异步操作的支持，使得网络编程变得更加简洁和高效。

## 5.2 案例分析：并行数据处理

### 5.2.1 数据处理的背景和目标

并行数据处理通常涉及到大量数据的分析、转换或计算，这在科学计算、数据挖掘、图像处理等领域极为常见。目标通常包括：

- 加速数据处理速度；
- 提高处理过程的效率；
- 实现处理过程的可扩展性。

### 5.2.2 并行处理的策略和优化

在使用C++11线程库进行并行数据处理时，可以考虑如下策略：

1. 数据分解：将数据集分解成更小的数据块，以分配给不同的线程处理；
2. 线程池：利用线程池来管理线程的创建和销毁，避免重复开销；
3. 任务调度：合理分配任务，避免某些线程过载而其他线程空闲。

下面是一个简单的并行处理数据的例子，使用了C++11的`std::async`来实现：

#include <iostream>
#include <future>
#include <vector>

// 假设这是一个计算密集型的函数
int compute_intensive_function(int data) {
    // 执行复杂的计算操作...
    return data * data;
}

int main() {
    std::vector<std::future<int>> futures;

    // 创建并启动多个异步任务
    for (int i = 0; i < 10; ++i) {
        futures.emplace_back(std::async(std::launch::async, compute_intensive_function, i));
    }

    // 等待所有异步任务完成，并获取结果
    for (auto& future : futures) {
        std::cout << "异步操作结果: " << future.get() << std::endl;
    }

    return 0;
}

在这个例子中，我们对10个数据项启动了异步任务，每个任务执行一个计算密集型函数。通过`std::async`启动任务，可以简化并发编程的复杂性，同时`std::future`用于异步结果的获取。

## 5.3 案例分析：高并发任务调度

### 5.3.1 调度系统的需求和设计

高并发任务调度要求系统能够处理高频率的任务请求，同时保证任务的有序执行和资源的合理分配。设计要点包括：

- 任务队列的管理；
- 调度策略的制定；
- 性能监控和调优。

### 5.3.2 高并发下的挑战与解决方案

高并发环境下，任务调度系统需要面对的主要挑战包括：

- 资源竞争与锁竞争问题；
- 线程死锁和资源泄露；
- 调度延迟和上下文切换开销。

为了应对这些挑战，我们可以采取如下解决方案：

- 采用无锁编程技术；
- 使用任务分派池来管理任务队列；
- 运用锁粒度控制和避免死锁的策略。

下面是一个简单的高并发任务调度的示例，展示了如何使用C++11线程库实现任务的并发调度：

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

// 任务队列和同步机制
std::queue<std::function<void()>> tasks;
std::mutex queue_mutex;
std::condition_variable condition;

void worker_thread() {
    while (true) {
        std::function<void()> task;

        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            condition.wait(lock, [] { return !tasks.empty(); });
            task = tasks.front();
            tasks.pop();
        }

        task();
    }
}

int main() {
    std::vector<std::thread> threads;
    const unsigned int thread_count = 5;

    // 创建线程池
    for (unsigned int i = 0; i < thread_count; ++i) {
        threads.emplace_back(worker_thread);
    }

    // 添加任务到队列
    for (int i = 0; i < 10; ++i) {
        tasks.emplace([i] {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::cout << "任务 " << i << " 执行完成" << std::endl;
        });
        condition.notify_one();
    }

    // 等待所有线程完成
    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

在这个例子中，我们创建了一个线程池，并向任务队列中添加了10个任务。每个任务执行后会休眠1秒钟来模拟计算密集型操作。线程池中的每个线程会等待并处理任务队列中的任务，直到任务队列为空。这展示了如何利用C++11线程库实现一个简单的线程池。

这些案例分析表明，C++11线程库在多线程网络服务器、并行数据处理和高并发任务调度等多种实际项目中的应用是灵活且强大的。它们为现代并发程序设计提供了一个稳固的基石，并且随着现代编译器优化和硬件的进步，其性能还有很大的提升空间。