什么是std::thread？
std::thread是C++11中引入的一个类，用于表示和管理线程。通过std::thread，我们可以创建一个新的线程来执行指定的任务。线程是操作系统调度的基本单位，多个线程可以并发执行，从而提高程序的效率。
创建线程
基本用法
要创建一个线程，只需实例化一个std::thread对象，并传入一个可调用对象（如函数、Lambda表达式或函数对象）作为参数。
#include <iostream>
#include <thread>
void hello() {
std::cout << "Hello from thread!\n";
}
int main() {
std::thread t(hello); // 创建一个线程，执行hello函数
t.join(); // 等待线程结束
return 0;
}
在这个示例中，我们创建了一个线程t，它执行hello函数。join()方法用于等待线程执行完毕。
使用Lambda表达式
我们也可以使用Lambda表达式来创建线程。
#include <iostream>
#include <thread>
int main() {
std::thread t([]() {
std::cout << "Hello from Lambda thread!\n";
});
t.join();
return 0;
}
带参数的线程函数
线程函数可以接受参数，只需在创建线程时传递相应的参数即可。
#include <iostream>
#include <thread>
void print_message(const std::string& message) {
std::cout << message << '\n';
}
int main() {
std::thread t(print_message, "Hello from thread with arguments!");
t.join();
return 0;
}
线程的管理
join()与detach()
join()：等待线程执行完毕。调用join()后，主线程会阻塞，直到子线程完成。detach()：将线程与std::thread对象分离，线程在后台独立运行。分离后的线程不能再被join()。
#include <iostream>
#include <thread>
#include <chrono>
void task() {
std::this_thread::sleep_for(std::chrono::seconds(1));
std::cout << "Task completed!\n";
}
int main() {
std::thread t(task);
t.detach(); // 分离线程
std::cout << "Main thread continues...\n";
std::this_thread::sleep_for(std::chrono::seconds(2)); // 等待子线程完成
return 0;
}
线程的移动语义
std::thread支持移动语义，可以将一个线程的所有权从一个std::thread对象转移到另一个。
#include <iostream>
#include <thread>
void task() {
std::cout << "Task executed!\n";
}
int main() {
std::thread t1(task);
std::thread t2 = std::move(t1); // 将t1的所有权转移给t2
t2.join();
return 0;
}
线程同步
多线程编程中，线程之间的共享资源可能会导致数据竞争问题。为了解决这个问题，C++提供了多种同步机制，如互斥锁（std::mutex）和条件变量（std::condition_variable）。
使用std::mutex
std::mutex用于保护共享资源，确保同一时间只有一个线程可以访问该资源。
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
std::mutex mtx;
int shared_data = 0;
void increment() {
for (int i = 0; i < 10000; ++i) {
std::lock_guard<std::mutex> lock(mtx); // 自动加锁和解锁
++shared_data;
}
}
int main() {
std::vector<std::thread> threads;
for (int i = 0; i < 10; ++i) {
threads.emplace_back(increment);
}
for (auto& t : threads) {
t.join();
}
std::cout << "Final value of shared_data: " << shared_data << '\n'; // 输出：100000
return 0;
}
使用std::condition_variable
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> lock(mtx);
cv.wait(lock, []() { return ready; }); // 等待条件成立
std::cout << "Thread " << id << " is running!\n";
}
int main() {
std::thread threads[10];
for (int i = 0; i < 10; ++i) {
threads[i] = std::thread(print_id, i);
}
std::this_thread::sleep_for(std::chrono::seconds(1));
{
std::lock_guard<std::mutex> lock(mtx);
ready = true; // 设置条件为true
}
cv.notify_all(); // 通知所有等待的线程
for (auto& t : threads) {
t.join();
}
return 0;
}
线程池的实现
虽然C++标准库没有直接提供线程池，但我们可以使用std::thread和其他工具（如std::queue和std::function）来实现一个简单的线程池。
#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
class ThreadPool {
public:
ThreadPool(size_t num_threads) {
for (size_t i = 0; i < num_threads; ++i) {
workers.emplace_back([this] {
while (true) {
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>
void enqueue(F&& f) {
{
std::unique_lock<std::mutex> lock(queue_mutex);
tasks.emplace(std::forward<F>(f));
}
condition.notify_one();
}
~ThreadPool() {
{
std::unique_lock<std::mutex> lock(queue_mutex);
stop = true;
}
condition.notify_all();
for (std::thread& worker : workers) {
worker.join();
}
}
private:
std::vector<std::thread> workers;
std::queue<std::function<void()>> tasks;
std::mutex queue_mutex;
std::condition_variable condition;
bool stop = false;
};
int main() {
ThreadPool pool(4);
for (int i = 0; i < 8; ++i) {
pool.enqueue([i] {
std::cout << "Task " << i << " is running on thread " << std::this_thread::get_id() << '\n';
std::this_thread::sleep_for(std::chrono::seconds(1));
});
}
return 0;
}
