C++11中的std::thread库提供了哪些功能？请举例说明如何使用它创建和管理线程。
参考回答
C++11 中的 std::thread 库提供了一种简单而高效的方式来创建和管理线程。通过 std::thread 类，程序可以创建新的线程，并将特定的函数或可调用对象传递给线程执行。每个线程都在独立的执行路径上运行，允许程序并发执行多个任务。
主要功能：
1. 创建线程：使用 std::thread 类来创建并启动线程。
2. 线程同步：通过互斥量（std::mutex）、条件变量（std::condition_variable）等机制来同步线程。
3. 线程管理：可以使用 join() 和 detach() 方法来管理线程的生命周期。
详细讲解与拓展
1. 基本的线程创建
std::thread 可以用来创建并启动新线程。要创建线程，我们需要将一个可调用对象（如函数、lambda 表达式、函数对象等）传递给 std::thread 的构造函数。线程会立即启动，并开始执行传入的函数。
示例：创建和启动线程
#include
#include
void printHello() {
std::cout << "Hello from thread!" << std::endl;
}
int main() {
// 创建并启动线程
std::thread t(printHello);
// 等待线程执行完毕
t.join();
std::cout << "Main thread finished." << std::endl;
return 0;
}
在这个例子中，我们定义了一个 printHello 函数，并通过 std::thread 启动一个新线程来执行这个函数。调用 t.join() 会使主线程等待子线程执行完毕后再继续执行。
2. 使用 Lambda 表达式创建线程
除了直接传递函数指针给 std::thread，我们还可以使用 lambda 表达式来传递可调用对象。这样可以使得线程执行更加灵活。
示例：使用 lambda 表达式创建线程
#include
#include
int main() {
// 使用 lambda 表达式创建线程
std::thread t([]() {
std::cout << "Hello from lambda thread!" << std::endl;
});
t.join(); // 等待线程执行完毕
return 0;
}
这个例子中，lambda 表达式作为线程函数传递给 std::thread，创建一个执行该表达式的线程。
3. 线程参数传递
如果线程需要传递参数，我们可以直接通过 std::thread 构造函数将参数传递给线程函数。这些参数会被自动传递给函数。
示例：传递参数给线程
#include
#include
void printNumbers(int start, int end) {
for (int i = start; i <= end; ++i) {
std::cout << i << " ";
}
std::cout << std::endl;
}
int main() {
int start = 1, end = 5;
// 传递参数给线程
std::thread t(printNumbers, start, end);
t.join(); // 等待线程执行完毕
return 0;
}
在这个例子中，我们传递了两个整数参数给 printNumbers 函数，线程在执行时会打印这些数字。
4. 线程的同步与互斥
在多线程环境下，多个线程可能会访问共享数据，从而导致数据竞争。为了解决这个问题，C++11 提供了 std::mutex 来确保同一时刻只有一个线程可以访问共享资源。
示例：使用 std::mutex 实现线程同步
#include
#include
#include
std::mutex mtx;
void printNumbers(int start, int end) {
std::lock_guard lock(mtx); // 上锁
for (int i = start; i <= end; ++i) {
std::cout << i << " ";
}
std::cout << std::endl;
}
int main() {
// 创建两个线程，打印不同范围的数字
std::thread t1(printNumbers, 1, 5);
std::thread t2(printNumbers, 6, 10);
t1.join();
t2.join();
return 0;
}
在这个例子中，std::mutex 用于保护共享资源，确保每个线程在打印数字时不会被其他线程干扰。std::lock_guard 是一个RAII风格的锁，它会在作用域结束时自动释放锁。
5. 线程的 join() 与 detach()
join()：调用join()会使主线程等待子线程完成执行。如果主线程在子线程执行完之前结束，那么程序会出现异常行为。因此，一般需要使用join()来确保主线程等待子线程完成。detach()：调用detach()会将线程与主线程分离，线程会在后台独立执行，而主线程不会等待它。被分离的线程无法再与主线程交互，且在主线程结束时，分离的线程也会被销毁。
示例：使用 join() 和 detach()
#include
#include
void printMessage() {
std::cout << "Hello from detached thread!" << std::endl;
}
int main() {
std::thread t(printMessage);
// 使用 join 等待线程执行完毕
t.join(); // 也可以使用 t.detach() 来让线程在后台运行
std::cout << "Main thread finished." << std::endl;
return 0;
}
如果使用 t.detach()，线程将在后台独立执行，主线程不会等待它。
6. 线程的异常处理
线程中出现的异常不会自动传播到主线程，因此需要在子线程内部处理异常，或者通过一些机制（如 std::future）将结果或异常传递回主线程。
示例：线程异常处理
#include
#include
#include
void throwException() {
throw std::runtime_error("An error occurred in the thread!");
}
int main() {
try {
std::thread t(throwException);
t.join();
} catch (const std::exception& e) {
std::cout << "Exception caught in main: " << e.what() << std::endl;
}
return 0;
}
在这个例子中，throwException 函数在子线程中抛出异常，主线程捕获并处理该异常。
总结
C++11 的 std::thread 库提供了简单而强大的线程创建与管理功能。通过 std::thread，我们可以方便地创建和启动线程，传递参数，进行线程同步与互斥操作，并且可以通过 join() 或 detach() 方法管理线程的生命周期。理解如何使用线程、如何同步线程以及如何处理线程中的异常是多线程编程的核心要点。