《Qt从零入门系列（十四）：QThread多线程详解——从线程创建到客户端阻塞处理》

沫璃染墨2026-10-19 9:35

在Qt程序开发中，我们经常会遇到这样的问题：执行一个耗时操作时，窗口突然卡住，按钮无法点击，界面也无法正常响应。等操作结束后，程序才恢复正常。这通常是因为耗时任务占用了 GUI 主线程，导致主线程无法及时处理界面事件。

为了解决这类问题，我们可以引入多线程，将耗时任务放到其他线程中执行，让主线程继续负责界面更新与用户交互。Qt提供了QThread 等线程相关机制，但要真正用好它们，还需要理解线程是如何创建和运行的、GUI操作为什么有线程限制，以及信号与槽如何在线程之间传递信息。

本文将从QThread的基本概念和核心API出发，通过继承QThread并重写run()函数，实现一个多线程倒计时案例。随后结合Qt客户端开发，分析阻塞操作导致界面卡顿的原因及处理思路，最后进一步讲解对象的线程归属、QThread的常见用法、线程退出注意事项和信号槽连接类型，为后续的Qt网络通信与项目开发打下基础。

目录

一、认识QThread：Qt多线程基础

[1.1 Qt线程与系统线程的关系](#1.1 Qt线程与系统线程的关系)

[1.2 QThread的基本设计思路：继承并重写run()](#1.2 QThread的基本设计思路：继承并重写run())

[1.2.1 run()：线程的执行入口](#1.2.1 run()：线程的执行入口)

[1.3 QThread核心API详解](#1.3 QThread核心API详解)

二、继承QThread实战：实现多线程倒计时

[2.1 GUI线程规则：为什么不能随意操作界面](#2.1 GUI线程规则：为什么不能随意操作界面)

[2.2 倒计时案例的实现步骤](#2.2 倒计时案例的实现步骤)

[2.2.1 thread.h：线程子类的声明](#2.2.1 thread.h：线程子类的声明)

[2.2.2 thread.cpp：线程执行逻辑的实现](#2.2.2 thread.cpp：线程执行逻辑的实现)

[2.2.3 widget.h：主窗口的声明](#2.2.3 widget.h：主窗口的声明)

[2.2.4 widget.cpp：主窗口与工作线程的交互](#2.2.4 widget.cpp：主窗口与工作线程的交互)

[2.3 程序执行时序：从启动线程到更新界面](#2.3 程序执行时序：从启动线程到更新界面)

三、Qt客户端中的多线程：解决阻塞与界面卡顿

[3.1 服务器多线程与Qt客户端多线程：应用目标有何不同](#3.1 服务器多线程与Qt客户端多线程：应用目标有何不同)

[3.2 客户端为什么会阻塞：耗时操作与同步等待](#3.2 客户端为什么会阻塞：耗时操作与同步等待)

[3.3 如何正确处理阻塞操作](#3.3 如何正确处理阻塞操作)

[3.4 Qt客户端多线程的典型应用场景](#3.4 Qt客户端多线程的典型应用场景)

四、QThread进阶：线程归属、使用方式与退出机制

[4.1 QThread对象的线程归属与run()的执行线程](#4.1 QThread对象的线程归属与run()的执行线程)

[4.1.1 QThread对象属于创建它的线程](#4.1.1 QThread对象属于创建它的线程)

[4.1.2 run()函数运行在新创建的线程中](#4.1.2 run()函数运行在新创建的线程中)

[4.1.3 为什么不能把QThread子类的槽函数直接当作工作线程任务？](#4.1.3 为什么不能把QThread子类的槽函数直接当作工作线程任务？)

[4.1.4 需要事件循环时，应该如何组织代码？](#4.1.4 需要事件循环时，应该如何组织代码？)

[4.2 QThread的两种常见用法](#4.2 QThread的两种常见用法)

[4.3 线程退出与资源清理：需要注意什么](#4.3 线程退出与资源清理：需要注意什么)

[4.4 信号与槽的连接类型及其线程行为](#4.4 信号与槽的连接类型及其线程行为)

一、认识QThread：Qt多线程基础

1.1 Qt线程与系统线程的关系

Qt多线程的底层，本质上仍然是操作系统原生线程。Linux下对应pthread，Windows下对应系统线程API。换句话说，Linux线程那套原理、线程安全的约束，在Qt多线程里一条不少，全都适用。

Qt做的事情，是在不同平台的原生线程API之上，做了一层跨平台封装。一套代码，多平台编译运行，平台差异被它挡在了身后。

并发技术对比

技术 特点 适用场景
Linux pthread C语言原生库，API繁琐，大量使用void*通用指针，内存管理复杂 实际业务开发很少直接使用
C++11 std::thread 对系统线程封装，支持lambda、可调用对象，具备类型检查，规避void* C++开发中使用广泛；底层依然封装操作系统线程
Qt QThread 面向对象封装，提供事件循环、信号槽线程间通信机制 更适配Qt GUI客户端开发

注意： 掌握操作系统原生线程原理，是理解上层std::thread、QThread的前置基础。

1.2 QThread的基本设计思路：继承并重写run()
1.2.1 run()：线程的执行入口

线程的核心是什么？说到底就一件事，指定一个入口函数，新线程被操作系统调度起来之后，就从这里开始跑业务逻辑。

不同技术，指定入口的方式不一样：

  • std::thread/pthread：传一个函数指针、一个lambda表达式，作为入口。

  • QThread 传统用法：继承QThread子类，重写虚函数run()，靠C++的多态机制来实现线程入口。

这里有个容易搞混的点：run()不是开发者手动调用的。 你调用的是QThread::start()。start一执行，操作系统创建内核线程，然后由Qt框架自动去调用子类重写的那个run()。开发者只负责把逻辑写进run()里，什么时候调，框架说了算。

多态不是白来的，它带着虚函数表运行时查找的微小开销。游戏引擎、高性能服务器这种把性能抠到极致的场景，往往会刻意规避。但Qt客户端GUI开发，对这点开销压根不敏感，继承重写run()就是常规开发模式，用着顺手，也够用。

1.3 QThread核心API详解
API 功能说明
virtual void run() 线程入口虚函数。子类重写它，业务逻辑就写在这里面。禁止手动调用，交给框架去触发。
void start(Priority = InheritPriority) 向操作系统发起创建线程的请求。线程已经在跑？再调也没效果。线程就绪后，自动执行run()。
static QThread* currentThread() 静态方法，返回当前正在执行代码所属的那个QThread对象指针。我是谁，它在哪，一查便知。
bool isRunning() const 判断内核线程是否处于运行状态。run()没执行完，返回true。
sleep(unsigned long secs) 线程休眠，单位秒。只对调用它的那条线程生效。
msleep(unsigned long msecs) 线程休眠，单位毫秒。
usleep(unsigned long usecs) 线程休眠，单位微秒。
bool wait(unsigned long time = ULONG_MAX) 阻塞等待线程结束，等价于Linux的pthread_join()。线程跑完或者超时，它才返回。线程还没启动？直接返回true。超时了？返回false。想永久阻塞，默认参数就够了。
void terminate() 强制终止线程。但操作系统什么时候调度、资源能不能安全释放，全都不确定。业务开发禁止使用，这是底线。
void finished() 信号 线程执行完毕时发射。绑个槽上去，就能顺手做线程资源的清理工作。

重点敲黑板：

sleep/msleep/usleep都是线程休眠 ，谁调用，谁就被阻塞。所以，**GUI主线程里绝对禁止调用休眠，**主线程一睡，界面事件循环当场冻结，窗口卡死，用户点什么都没反应。要睡，去工作线程里睡。

二、继承QThread实战：实现多线程倒计时

2.1 GUI线程规则：为什么不能随意操作界面

这条规矩，必须刻进骨头里：

所有控件、界面组件，只能在主线程（GUI线程）里操作和修改。其他子线程，禁止直接读写 UI 控件。 碰了？程序当场崩溃给你看。

那子线程干什么？只负责计算、计时、IO处理这些幕后活儿。要跟界面打交道，走正规渠道，子线程通过自定义信号把数据发出去，信号槽跨线程通知主线程，主线程的槽函数内部再去更新界面。

跨线程的信号槽，默认自动使用Qt::QueuedConnection队列连接。事件循环会把信号分发到接收者所属的线程，槽函数在那个线程里执行。发的人只管发，接的人在自己的地盘上处理，安全又规矩。

2.2 倒计时案例的实现步骤

整个倒计时案例，分五步走：

  1. 搭界面：创建Qt Widget项目，UI界面上放一个QLCDNumber数字显示控件。倒计时的数字，就靠它来亮。

  2. 建线程类：创建C++类Thread，继承QThread，别忘了启用Q_OBJECT宏，没有它，信号槽玩不转。

  3. 写入口和信号：子类重写run()作为线程入口；再定义自定义信号，专门用来向主线程通知计时事件。

  4. 连信号槽：Widget主线程里创建Thread对象，connect把信号槽绑好，然后调用start()启动子线程。

  5. 跑起来：子线程在run()里循环计时、休眠，通过 emit 发射信号；主线程的槽函数接到信号，更新LCD显示。

2.2.1 thread.h：线程子类的声明
cpp 复制代码 
#ifndef THREAD_H
#define THREAD_H

#include <QThread>

class Thread : public QThread
{
    Q_OBJECT
public:
    explicit Thread();

protected:
    // 重写线程入口函数run，protected虚函数
    void run() override;

signals:
    // 自定义信号，无需实现，MOC工具会自动生成
    void notify();
};

#endif // THREAD_H
2.2.2 thread.cpp：线程执行逻辑的实现
cpp 复制代码 
#include "thread.h"

Thread::Thread()
{

}

void Thread::run()
{
    // 子线程执行逻辑，禁止操作 UI 控件
    for (int i = 0; i < 10; ++i)
    {
        // 休眠 1 秒，阻塞的是当前子线程，GUI 主线程不受影响
        sleep(1);
        // 发射自定义信号，通知主线程更新界面
        emit notify();
    }
}

run()里的循环，就是倒计时的节奏。每睡一秒，发一次notify()信号。注意，休眠睡的是子线程，主线程该跑跑、该刷刷，一点都不耽误。UI控件？子线程碰都不碰，只负责发信号。

2.2.3 widget.h：主窗口的声明
cpp 复制代码 
#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include "thread.h"

QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private slots:
    // 槽函数：接收子线程信号，更新 UI
    void handle();

private:
    Ui::Widget *ui;
    Thread thread; // 子线程对象
};

#endif // WIDGET_H
2.2.4 widget.cpp：主窗口与工作线程的交互
cpp 复制代码 
#include "widget.h"
#include "ui_widget.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    // 绑定子线程 notify 信号到主线程 handle 槽函数
    // 跨线程自动使用 QueuedConnection
    connect(&thread, &Thread::notify, this, &Widget::handle);

    // 启动子线程，调用操作系统 API 创建内核线程，自动执行 run()
    thread.start();
}

Widget::~Widget()
{
    // 析构前确保线程执行完毕，防止对象销毁了线程还在跑
    thread.wait();
    delete ui;
}

void Widget::handle()
{
    // 槽函数运行在主线程，可以安全操作 UI 控件
    int value = ui->lcdNumber->intValue();
    value--;
    ui->lcdNumber->display(value);
}

这段代码，把整个流程串了起来。

构造函数里，connect把子线程的notify信号，接到主线程的handle槽上。跨线程的信号槽，Qt默认走QueuedConnection队列连接，信号发出去，先排队，再由主线程的事件循环取出来，在主线程里执行槽函数。所以handle()里操作UI，完全安全。

thread.start()一调，操作系统创建内核线程，Qt框架自动执行run()，倒计时就转起来了。

析构函数里那句thread.wait()，是保命的。线程还在跑，对象就被销毁了，程序直接崩。wait()一卡，等线程跑完再往下走，稳当。

handle()里就三行：读出LCD当前值，减一，写回去。简单，但安全。因为它跑在主线程，UI 控件随便碰。

2.3 程序执行时序：从启动线程到更新界面

整个程序跑起来，时序是这样的：

  1. Widget 构造函数执行，thread.start()一调，操作系统立刻动手，创建子线程。此时主线程继续往下走，子线程还在后台待命。

  2. **子线程被调度，进入Thread::run()。**循环开始，每次先sleep(1)，睡满一秒，然后emit notify()发一次信号。一睡一发，节奏卡得刚刚好。

  3. 信号跨线程投递。notify()不是直接跑到主线程去执行，而是被放进主线程的事件队列，排着队等处理。发信号的人把信封塞进邮筒，至于什么时候被拆开，那是收件人的事。

  4. 主线程事件循环取出事件，执行handle()槽函数。LCD上的数字减一，界面刷新。整个过程在主线程里完成，UI操作绝对安全。

  5. for循环跑满10次，run()函数return，线程结束，顺手发射finished()信号。倒计时到此收工。

五步走完，一个完整的多线程倒计时就转了一圈。子线程计时、发信号，主线程收信号、刷界面，两条线各跑各的，靠信号槽这根线牵着，谁也不越界，谁也不耽误谁。

三、Qt客户端中的多线程：解决阻塞与界面卡顿

3.1 服务器多线程与Qt客户端多线程：应用目标有何不同

服务器端多线程，图的是榨干CPU。多核并行，计算任务铺开跑，能快一分是一分，核心指标就是吞吐和速度。

Qt客户端GUI程序多线程，目标完全不同，解阻塞。 它不追求把CPU压到极限，而是要保住主线程的事件循环，别让界面卡死。一个求"算得快"，一个求"别卡住"，出发点是两码事。

3.2 客户端为什么会阻塞：耗时操作与同步等待

GUI主线程的职责，是跑事件循环，处理鼠标、键盘、窗口绘制这些用户交互。它就像一个前台接待，得时刻在岗，随时响应。

可一旦主线程去执行耗时IO操作，网络大文件上传下载、大批量磁盘读写、加载大型资源了，它就会被系统阻塞挂起。事件循环一停，前台就没人了。

现象很直接：窗口无响应，操作系统弹出"程序未响应"，用户点什么都没反应。界面，就这么冻住了。

3.3 如何正确处理阻塞操作

思路就一句话：耗时的活儿，挪出去干。

  • 把耗时IO、等待类业务放到独立子线程执行。阻塞只会发生在子线程身上，主线程不受牵连。

  • 主线程继续跑事件循环，持续响应用户操作，界面始终跟手。

  • 子线程计算或IO完成，通过信号槽把结果回传给主线程，由主线程更新界面。

子线程埋头干活，主线程守住前台。两边各司其职，界面才不会卡。

3.4 Qt客户端多线程的典型应用场景
场景 具体例子
网络 大文件上传下载、网络请求等待响应
IO 大批量磁盘文件读写、加载大型资源文件
后台计算 耗时数据处理，不允许卡住界面

这些活儿，共同点就一个：慢。慢活儿留在主线程，界面必卡。挪到子线程，主线程才能一直保持响应，用户体验才稳得住。

四、QThread进阶：线程归属、使用方式与退出机制

4.1 QThread对象的线程归属与run()的执行线程

在学习QThread时，有一个很容易混淆的知识点：QThread对象属于哪个线程，与run()函数在哪个线程中执行，是两回事。

我们先看一个简单的例子：

cpp 复制代码 
class MyThread : public QThread
{
    Q_OBJECT

protected:
    void run() override
    {
        qDebug() << "run线程ID：" << QThread::currentThreadId();
    }
};

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    MyThread thread;

    qDebug() << "创建对象时的线程ID："
             << QThread::currentThreadId();

    thread.start();

    return a.exec();
}

这里需要区分两个概念：线程对象的归属 和代码的实际执行位置。

4.1.1 QThread对象属于创建它的线程

QThread本身继承自QObject，因此也具有线程归属（Thread Affinity）。

例如，上面的MyThread thread; 是在主线程中创建的，那么这个MyThread对象就属于主线程。调用thread.start()并不会改变它的线程归属。

换句话说，QThread对象主要负责管理一个线程，它本身并不会因为启动线程就自动迁移到新线程中。

4.1.2 run()函数运行在新创建的线程中

当调用start()后，Qt会启动一个新的系统线程，并在新线程中执行run()函数。

因此，上面代码中的线程关系可以理解为：

  • 主线程： 创建并管理MyThread对象，继续处理GUI事件。

  • 新线程： 执行MyThread::run()中的代码。

需要注意的是，run()是在线程中执行的函数，而不是负责管理线程对象的函数。重写run()，只是让我们能够自定义新线程启动后的工作内容。

4.1.3 为什么不能把QThread子类的槽函数直接当作工作线程任务？

既然run()在新线程中执行，是否意味着MyThread类中定义的所有函数和槽函数也会自动在新线程中执行？答案是否定的。

例如，我们在MyThread中定义一个槽函数：

cpp 复制代码 
public slots:
    void doWork()
    {
        qDebug() << QThread::currentThreadId();
    }

如果通过队列连接（Qt::QueuedConnection）调用这个槽函数，Qt会根据接收者对象的线程归属来决定槽函数在哪个线程执行。

由于MyThread对象仍然属于创建它的主线程，因此这个槽函数通常会在主线程中执行，而不是因为它属于QThread的子类，就自动转移到新线程中。

这也是初学者使用QThread时容易遇到的问题：run()在新线程中执行，并不代表这个类的所有成员函数都在新线程中执行。

4.1.4 需要事件循环时，应该如何组织代码？

如果任务只是执行一段独立的计算或耗时操作，继承QThread并重写run()通常就可以满足需求。

但如果工作线程需要使用依赖事件循环的机制，例如定时器、Socket，或者需要通过槽函数接收其他对象发送的任务，那么更常见的方式是将一个独立的工作对象移动到工作线程中。

例如：

cpp 复制代码 
QThread *thread = new QThread(this);
Worker *worker = new Worker;

worker->moveToThread(thread);

connect(thread, &QThread::started,
        worker, &Worker::process);

connect(worker, &Worker::finished,
        thread, &QThread::quit);

connect(worker, &Worker::finished,
        worker, &QObject::deleteLater);

connect(thread, &QThread::finished,
        thread, &QObject::deleteLater);

thread->start();

这里的Worker是一个继承自QObject的工作对象。调用moveToThread()后，它的线程归属变为对应的工作线程。通过队列连接调用它的槽函数时，只要满足相应的线程与事件循环条件，槽函数就可以在工作线程中执行。

还有一个细节需要注意：QThread默认的run()实现会调用exec()，启动该线程的事件循环；如果我们重写run()，却没有调用exec()，就不会自动获得这一事件循环。因此，需要定时器或依赖事件循环的异步通信时，要特别注意线程的启动方式和事件循环是否运行。

当然，moveToThread()也不是简单地把对象挪过去就万事大吉了。对象的父子关系、对象创建的位置，以及相关操作是否发生在所属线程中，都需要正确处理。尤其是使用QTcpSocket或QUdpSocket时，应当确保Socket在正确的线程中创建和使用。

总的来说，可以记住下面这句话：

QThread负责管理线程，run()决定新线程启动后执行什么，而QObject的线程归属决定了与事件循环相关的槽函数等机制在哪个线程中工作。

特别注意：QThread对象的线程归属不等于run()的执行线程。

这是使用QThread时极容易混淆的一个问题。通常情况下，QThread对象在哪里创建，就属于哪个线程；调用start()后，Qt启动的新线程才会执行run()中的代码。

因此，不能认为继承QThread后，这个类的所有成员函数都会自动在新线程中执行。通过队列连接调用槽函数时，槽函数的执行线程通常由接收者对象的线程归属决定；而在run()中直接访问成员变量或成员对象时，还需要考虑是否存在跨线程访问和数据竞争。

这里并不是说QThread子类不能有成员对象，也不是说不能在run()外部建立信号槽连接，而是要明确对象属于哪个线程、代码实际在哪个线程执行，以及访问对象时是否满足线程安全要求。

如果任务只需要执行一段独立的工作，可以继承QThread并重写run()；如果需要在线程中使用定时器、Socket，或者通过槽函数持续接收任务，通常更适合将独立的QObject工作对象通过moveToThread()移交给工作线程，并正确处理事件循环、对象生命周期和线程退出。

4.2 QThread的两种常见用法
用法 特点 适用场景
继承重写run() 本笔记示例用法，业务逻辑写死在run()里 业务逻辑完整、循环常驻运行的任务
QObject + moveToThread() 不继承QThread，把工作对象移动到QThread里 信号槽驱动、存在事件循环的任务（Qt官方更推荐）

两种用法，各有所长。一个适合"一条道跑到黑"的常驻任务，一个适合"来一个信号干一件事"的响应式任务。官方更偏爱后者，但前者在简单场景里也够用。

4.3 线程退出与资源清理：需要注意什么

  • 禁止调用terminate()强制杀死线程。 线程被强行掐断，资源来不及释放，内存泄漏、程序崩溃，后患无穷。

  • 循环任务线程，推荐设置原子bool标记位，控制run()循环正常退出。外部调用wait()，等线程安全结束。

  • 对象析构前，务必保证线程已经结束。 对象都销毁了，线程还在访问成员，程序当场崩溃wait()就是那道保险。

4.4 信号与槽的连接类型及其线程行为
连接类型 行为 安全性
Qt::AutoConnection**（默认）** 发送与接收在同一线程，直接调用；跨线程自动变为QueuedConnection，投递到接收线程的事件循环执行 安全
Qt::QueuedConnection 信号发送线程立即返回，槽函数在接收者线程的事件循环里执行 跨线程安全
Qt::DirectConnection 槽函数直接在信号发射线程执行 跨线程使用会引发线程安全问题

默认的AutoConnection最省心，同线程直接调，跨线程自动排队，不用你操心。QueuedConnection明确走队列，跨线程稳当。DirectConnection则要小心，它不管三七二十一，直接在发射信号的线程里执行槽函数，跨线程用，就是在刀尖上跳舞。

到这里，Qt多线程QThread的基础部分，就完整走了一遍。

从QThread与系统线程的关系，到继承重写run()的传统用法；从多线程倒计时的实战案例，到客户端多线程真正要解决的"解阻塞"问题；再到对象依附线程、两种主流用法、线程退出和信号槽连接类型这些补充知识点，整套东西串下来，Qt多线程的骨架就立起来了。

几个关键认知，再帮你钉一遍：

  • Qt 多线程底层还是系统线程。 Linux下就是pthread，原理和线程安全约束一条不少，别以为换了Qt就能绕开。

  • UI控件只能在主线程碰。 子线程只负责计算、IO，结果通过信号槽回传主线程更新界面。跨线程直接操作 UI，程序崩你没商量。

  • 继承重写run()有它的边界。 QThread对象本身依附创建它的线程，给子类加成员对象、在run()外绑信号槽，都容易踩跨线程访问的坑。简单常驻任务用它没问题，复杂场景更推荐moveToThread()。

  • 别用terminate()。 强制杀死线程，资源泄漏、崩溃风险全来了。用原子标记位控制循环退出，再 wait() 等线程安全收尾，这才是正路。

  • 信号槽默认的AutoConnection最省心。 同线程直接调，跨线程自动排队。DirectConnection跨线程用，就是在给自己找麻烦。

QThread这一篇，是Qt并发编程的起点。往后还有线程同步、线程池、异步任务这些更复杂的题目等着我们。基础打牢了，后面才走得稳。

如果这篇文章对你有帮助，别忘了点赞、收藏、关注三连支持。你的每一次反馈，都是我继续硬核输出的最大动力。我们下篇见。

相关推荐
xiayutian_c1 小时前
BTP Event Mesh
笔记
草莓熊Lotso1 小时前
【C++ 基于微服务的即时通讯系统】Elasticsearch 从安装到 C++ 客户端二次封装全落地
linux·网络·数据库·c++·elasticsearch·微服务
hixiong1231 小时前
C# 使用 ZXingCpp.Angle 进行条码、二维码识别
开发语言·c#·扫码
CHPCWWHSU1 小时前
FreeCAD 源码解读：从 Property 到 Command，看一套 CAD 内核的完整闭环
c++·cad
云和数据.ChenGuang1 小时前
AI 工程师相关就业岗位（细分，偏工程落地，由底层到上层）
服务器·开发语言·人工智能·python
爱读书的小胖1 小时前
Codewars：Last digit of a large number（C）解题分析
c语言·开发语言·r语言
代钦塔拉1 小时前
【C++/Qt 进阶】设计模式系列(5)：适配器模式——给“不兼容的接口“贴一层翻译膜
c++·qt·设计模式
aqiu1111111 小时前
蓝桥杯真题复盘：Fibonacci 数列与黄金分割（C++ 算法详解）
c++·算法·蓝桥杯
码途行者1 小时前
处理超时未支付订单：两套轻量化方案，附 PHP 极简实现
开发语言·redis·php
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02「全语录+省流版」邵艾伦 × 孙宇晨：聊风口、聊个人IP、聊年轻人如何抓住 AI 时代的机会03如何新建文件夹？ 电脑新建文件夹的4种方法04GitHub 镜像站点05历年考研数学一、数学二、数学三真题试卷及答案PDF06几个好用的ip纯净度检测网站07蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接08Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）09Telegram APK 下载安装完整指南 — 2026年最新10苹果iPA游戏软件资源下载网站