一、纯C++实现线程的方式（C++11及以上）

纯C++的线程能力来自标准库（<thread>），核心只有2类核心方式（本质都是基于std::thread），没有多余的“变种”，语法和平台无关（Windows/Linux通用）：

1. 基础方式：直接使用std::thread绑定可执行对象

这是最核心的方式，std::thread创建后立即启动新线程，可绑定函数、lambda、类成员函数等：

#include <thread> #include <iostream> #include <chrono> // 1. 绑定普通函数 void task1(int num) { for (int i = 0; i < 3; ++i) { std::cout << "任务1（线程ID：" << std::this_thread::get_id() << "）：" << num + i << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(500)); } } // 2. 绑定类成员函数 class TaskClass { public: void task2(const std::string& msg) { for (int i = 0; i < 3; ++i) { std::cout << "任务2（线程ID：" << std::this_thread::get_id() << "）：" << msg << i << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(500)); } } }; int main() { std::cout << "主线程ID：" << std::this_thread::get_id() << std::endl; // 方式1：启动普通函数线程 std::thread t1(task1, 10); // 方式2：启动类成员函数线程 TaskClass obj; std::thread t2(&TaskClass::task2, &obj, "测试"); // 等待线程结束（必须join，否则主线程退出会导致程序崩溃） t1.join(); t2.join(); return 0; }

2. 进阶方式：线程池（基于std::thread封装）

纯C++没有内置线程池，需自己封装或用第三方库（如boost::thread_pool），核心是复用线程、减少线程创建销毁的开销，适合大量短任务场景：

// 简化版线程池示例（核心思路） #include <thread> #include <vector> #include <queue> #include <mutex> #include <condition_variable> class ThreadPool { public: ThreadPool(int numThreads) { // 创建指定数量的线程，循环等待任务 for (int i = 0; i < numThreads; ++i) { m_workers.emplace_back([this]() { while (true) { std::function<void()> task; // 加锁取任务 { std::unique_lock<std::mutex> lock(m_mtx); m_cv.wait(lock, [this]() { return m_stop || !m_tasks.empty(); }); if (m_stop && m_tasks.empty()) return; task = std::move(m_tasks.front()); m_tasks.pop(); } // 执行任务 task(); } }); } } // 添加任务到队列 template<class F> void enqueue(F&& f) { { std::unique_lock<std::mutex> lock(m_mtx); m_tasks.emplace(std::forward<F>(f)); } m_cv.notify_one(); // 唤醒一个线程执行任务 } // 销毁线程池 ~ThreadPool() { { std::unique_lock<std::mutex> lock(m_mtx); m_stop = true; } m_cv.notify_all(); // 唤醒所有线程 for (auto& worker : m_workers) { if (worker.joinable()) worker.join(); } } private: std::vector<std::thread> m_workers; // 线程池 std::queue<std::function<void()>> m_tasks; // 任务队列 std::mutex m_mtx; // 互斥锁 std::condition_variable m_cv; // 条件变量 bool m_stop = false; // 停止标志 }; // 使用线程池 int main() { ThreadPool pool(4); // 创建4个线程的线程池 for (int i = 0; i < 10; ++i) { pool.enqueue([i]() { std::cout << "线程池执行任务" << i << "，线程ID：" << std::this_thread::get_id() << std::endl; std::this_thread::sleep_for(std::chrono::milliseconds(100)); }); } return 0; }

二、Qt框架中实现线程的方式（3种核心方式）

Qt基于纯C++扩展了线程能力，核心有3种方式，底层仍依赖操作系统线程，但封装了更贴合Qt生态的接口（信号槽、事件循环）：

方式1：继承QThread重写run()（基础方式）

• 核心：QThread是线程控制器，重写run()函数，run()内的代码在新线程执行；
• 适用：简单、单一的循环任务（如持续采集传感器数据）；
• 示例：

#include <QThread> #include <QDebug> class SimpleThread : public QThread { Q_OBJECT protected: void run() override { for (int i = 0; i < 3; ++i) { qDebug() << "QThread线程执行：" << i << "，线程ID：" << QThread::currentThreadId(); msleep(500); // Qt封装的延时（避免用std::this_thread） } } }; // 使用 // SimpleThread t; // t.start(); // 启动线程，自动调用run() // t.wait(); // 等待线程结束

方式2：QObject + moveToThread()（Qt官方推荐，主流方式）

• 核心：将业务逻辑封装在QObject子类中，通过moveToThread()移到QThread，用信号槽触发任务，解耦“线程管理”和“业务逻辑”；
• 适用：绝大多数场景（网络通信、异步解析、多任务调度）；
• 示例：

#include <QThread> #include <QObject> #include <QDebug> class Worker : public QObject { Q_OBJECT public slots: void doWork() { qDebug() << "moveToThread执行任务，线程ID：" << QThread::currentThreadId(); // 耗时任务逻辑... } }; // 使用 // QThread thread; // Worker* worker = new Worker; // worker->moveToThread(&thread); // thread.start(); // // 信号槽触发任务 // QMetaObject::invokeMethod(worker, "doWork");

方式3：Qt线程池QThreadPool（进阶方式）

• 核心：Qt内置线程池，无需手动封装，结合QRunnable使用，适合大量短任务；
• 适用：批量处理小任务（如批量解析数据、批量网络请求）；
• 示例：

#include <QThreadPool> #include <QRunnable> #include <QDebug> class MyRunnable : public QRunnable { public: void run() override { qDebug() << "QThreadPool执行任务，线程ID：" << QThread::currentThreadId(); // 任务逻辑... } }; // 使用 // MyRunnable* runnable = new MyRunnable; // runnable->setAutoDelete(true); // 执行完自动销毁 // QThreadPool::globalInstance()->start(runnable); // 加入全局线程池执行

三、纯C++线程 vs Qt线程：核心差异（是否相同？）

二者底层原理相同（都是调用操作系统的线程接口），但封装形式、生态适配、使用方式完全不同，核心差异如下：

总结

1. 纯C++线程：只有2类核心方式（std::thread直接使用、基于std::thread封装线程池），语法通用但需手动处理线程通信和管理；
2. Qt线程：有3种核心方式（继承QThread、QObject+moveToThread、QThreadPool），底层基于C++但封装了Qt生态特性（信号槽、自动管理），是Qt项目的首选；
3. 二者底层原理相同（都是操作系统线程），但封装形式和使用场景完全不同——Qt线程是纯C++线程在Qt生态下的“定制增强版”。