C++ main函数中启动线程

在C++中启动线程可以使用标准库中的`std::thread`类。具体操作步骤如下：

1. 在`<thread>`头文件中包含`std::thread`类。

2. 定义一个函数，该函数将作为新线程的入口点。

3. 创建一个`std::thread`对象并将函数名作为参数传递给它，例如：

void threadFunc() {
    std::cout << "New thread started" << std::endl;
}

int main() {
    std::thread t(threadFunc);
    // 等待线程结束
    t.join();
    return 0;
}

在此示例中，`threadFunc`函数被定义为新线程的入口点。`std::thread`类的构造函数将函数名作为参数传递，创建一个新线程。然后，`join()`函数在主线程中等待新线程执行完成后返回。

注意：如果您希望线程在后台运行并且不会阻塞主线程，请使用`std::thread`的`detach()`函数。但是，使用`detach()`函数启动的线程无法使用`join()`函数等待其结束。

相关问题

C++一个子线程不断更新变量，main函数中如何通过注册回调函数和回调函数，获取子线程中当前的变量的

在C++中，如果你想让一个子线程持续更新一个变量，然后在主线程中通过回调函数获取这个变量的新值，可以使用`std::condition_variable`配合`std::thread`来实现。这里有一个基本的例子：

#include <thread>
#include <mutex>
#include <condition_variable>

class VariableProvider {
public:
    int value = 0; // 变量
    mutable std::mutex mtx; // 保护变量
    std::condition_variable cv; // 用于同步线程

    // 更新变量的函数
    void updateValue(int new_value) {
        std::unique_lock<std::mutex> lock(mtx);
        value = new_value;
        cv.notify_one();  // 触发等待的线程
    }

    // 回调函数，主线程注册并等待变量变化
    void registerCallback(std::function<void(const int&)> callback) {
        std::thread(callback_thread, [this, &callback]() {
            while (true) {
                std::unique_lock<std::mutex> lock(mtx);
                cv.wait(lock, []{ return value != 0; });  // 等待直到有新值
                if (value != 0) {
                    callback(value);  // 调用回调函数
                }
            }
        });
    }
};

int main() {
    VariableProvider provider;
    
    provider.registerCallback([](const int& value) {  // 注册回调函数
        std::cout << "New value is: " << value << '\n';
    });

    // 启动子线程更新变量
    std::thread update_thread([&provider](){
        for (int i = 0; ; ++i) {
            provider.updateValue(i);  // 每次循环更新变量
        }
    });

    update_thread.join();  // 确保子线程结束再退出main
    return 0;
}

在这个示例中，`VariableProvider`类包含一个`updateValue`方法，它在线程安全的方式下更新变量，并唤醒等待在条件变量上的线程。`registerCallback`方法启动一个新的线程，该线程不断地从条件变量上获取新的变量值，并调用用户提供的回调函数。

qt c++ 定时执行函数子线程

在Qt C++中，可以使用QTimer类实现在子线程中定时执行函数。

首先，我们需要创建一个继承自QObject的子类，用于执行定时操作。在该子类中，通过继承QRunnable接口，使其可以在子线程中运行。具体代码如下：

#include <QObject>
#include <QRunnable>
#include <QTimer>

class TimerRunnable : public QObject, public QRunnable
{
    Q_OBJECT
public:
    TimerRunnable(QObject* parent = nullptr) : QObject(parent) {}

    void run() override {
        QTimer timer(this);  // 创建定时器
        connect(&timer, &QTimer::timeout, this, &TimerRunnable::executeFunction);  // 连接定时器的timeout信号与槽函数
        timer.start(1000);  // 设置定时器间隔为1秒
    }

signals:
    void functionToExecute();  // 准备执行的槽函数的信号

private slots:
    void executeFunction() {
        // 执行需要定时执行的函数
        emit functionToExecute();
    }
};

接下来，我们可以在主线程中使用QThreadPool来启动子线程并执行定时操作。具体代码如下：

#include <QCoreApplication>
#include <QThreadPool>

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

    TimerRunnable timerRunnable;
    QThreadPool::globalInstance()->start(&timerRunnable);  // 启动子线程

    QObject::connect(&timerRunnable, &TimerRunnable::functionToExecute, [](){
        // 需要定时执行的函数
        qDebug() << "Executing function...";
    });

    return a.exec();
}

在上述代码中，通过连接TimerRunnable的functionToExecute信号与槽函数，可以在每次定时器超时时执行需要定时执行的函数。需要注意的是，由于定时器的timeout信号与槽函数是跨线程的，所以需要通过信号与槽的方式进行连接。

以上代码实现了在子线程中定时执行函数的功能。