子线程共享main函数里的变量吗

子线程可以访问和修改与主线程共享的变量，但需要注意线程安全问题。如果多个线程同时访问和修改同一个变量，可能会导致数据不一致或者竞态条件等问题。为了确保线程安全，可以使用互斥锁等同步机制保证多个线程对共享变量的访问和修改是串行化的。此外，也可以使用线程局部存储（Thread Local Storage）的方式，使得每个线程都拥有一份独立的变量副本，避免了线程间的竞争。

相关问题

C++子线程执行的函数参数，如何在子线程外注册回调函数查看子线程内参数的变化

在C++中，子线程通常不会直接将内部变量暴露给主线程，因为它们运行在独立的数据上下文中。如果你想要在子线程执行过程中修改的数据能够在线程结束后通知到主线程，你可以使用共享内存（如`boost::interprocess`或`std::mutex`、`std::condition_variable`等）以及回调函数。

一种常见的做法是在子线程开始前创建一个数据结构（例如`std::pair<int, std::function<void(int)>>`），其中包含你要观察的值和一个回调函数。然后，每当子线程内的值发生变化时，它可以直接更新这个值，并调用回调函数。

这里是使用`std::async`创建子线程并传递回调函数的一个示例：

#include <future>
#include <iostream>

// 回调函数模板
template<typename T>
void update_and_notify(T value, std::function<void(T)> callback) {
    // 更新值
    value++;
    
    // 调用回调函数
    callback(value);
}

int main() {
    int shared_value = 0;
    std::function<void(int)> notify_callback = [&](int val) {
        std::cout << "Callback called with value: " << val << std::endl;
    };

    auto future = std::async(std::launch::async, update_and_notify, shared_value, notify_callback);

    // 主线程在这里继续工作，子线程会异步执行

    // 如果需要，你可以获取结果
    if (future.wait_for(std::chrono::seconds(5)) == std::future_status::ready) {
        std::cout << "Future result: " << future.get() << std::endl;
    }

    return 0;
}

在这个例子中，当你想要查看子线程中`shared_value`的变化时，`notify_callback`会被调用。注意，这种方式假设子线程不会无限期地阻塞，如果子线程执行时间过长，`wait_for`可能需要更复杂的错误处理。

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

在C++中，如果你有一个子线程不断更新某个全局或静态变量，并希望在主线程中通过函数指针接收这个变量的变化并执行相应的回调操作，可以采用条件变量（condition_variable）、互斥锁（mutex）以及共享内存（shared_ptr）等机制来实现。

首先，你需要创建一个共享数据容器，比如`std::atomic<T>`或者`std::shared_ptr<T>`，用于存储需要更新的值。然后，在子线程中修改这个变量，同时使用一个条件变量来通知主线程变化：

#include <thread>
#include <atomic>
#include <condition_variable>
#include <functional>

// 共享变量
std::atomic<int> shared_var{0};
std::condition_variable cv;
bool done = false;

void update_thread() {
    // 更新变量...
    shared_var++;
    // 当更新完成，通知主线程
    cv.notify_all();
}

void on_update(int value) {
    // 这是你想要的回调函数，它会在主线下游运行
    std::cout << "Variable updated to: " << value << std::endl;
}

int main() {
    std::thread worker(update_thread);
    
    // 注册回调函数
    auto callback = std::bind(on_update, shared_var.load()); // 获取当前值
    std::unique_lock<std::mutex> lock(cv_mutex); // 加锁

    while (!done) { // 循环等待直到子线程结束
        cv.wait(lock, [] { return shared_var != 0 || done; }); // 等待条件满足
    }

    // 主线程关闭条件变量
    done = true;
    cv.notify_one(); // 唤醒主线程
    worker.join(); // 等待子线程结束
    
    return 0;
}

每次`update_thread()`更新完变量后会唤醒主线程，这时你可以从`shared_var.load()`获取到最新的值并调用注册的回调函数。