堆栈内存溢出
  繁体   English   中英

线程阻塞代码 c++ 的 main()

[英]thread is block the main() of the code c++

 原文  2023-01-20 10:33:08  5   1    c++/ multithreading/ boost/ pthreads

问题描述

我正在尝试为 wait() 方法实现线程，这样它就不会阻塞 main() 线程。
在主线程中，wait() function 必须每小时运行一次验证 function。 因此， main() 线程在 wait() function 运行时被阻塞，并且不会继续执行任何代码，直到 wait() function 完成或线程被加入。 所以我想独立于 main() 运行 wait()。

主.cpp

#include <iostream>
#include <fstream>
#include <time.h>
#include <sys/stat.h>
#include <boost/date_time.hpp>
#include <boost/thread/thread.hpp> 
#include <boost/filesystem.hpp>
#include <boost/thread.hpp>
#include <pthread.h>

using namespace std;

constexpr char clock_file[] = "/home/saman/Desktop/clock";
constexpr char sync_file[] = "/home/saman/Desktop/hi/hi/synchronized";

class TimeEvent {
public:
     void receive_time_event(timespec& time) {
        // Create clock file
        ofstream clockFile(clock_file);
        if (!clockFile.is_open()) {
            cout << "Failed to open file" << endl;
        }
        clockFile.close();
        // Create synchronized file
        boost::filesystem::path dir(sync_file);
        boost::filesystem::create_directories(dir.parent_path());
        ofstream synchronizedFile(sync_file);
        if (!synchronizedFile.is_open()) {
            cout << "Failed to open file" << endl;
        }
        synchronizedFile.close();
    }

    timespec get_latest_clock_entry(){
    cout << "hello" << endl;
}
    void wait(){
        while(1){
        cout << "start wait" << endl;
        auto Now_Time = boost::posix_time::second_clock::local_time();
        auto update_Time = Now_Time + boost::posix_time::minutes(1);
        auto counter = update_Time - Now_Time;
        boost::this_thread::sleep(counter);
        validate();
        }
    }

    void validate(){
        // cout << "hi" << endl;
        timespec currentTime;  
        timespec_get(&currentTime, TIME_UTC);
        timespec ModifiedTime = get_latest_clock_entry();
        if (currentTime.tv_sec > ModifiedTime.tv_sec){
            ofstream clockfile(clock_file);
            if (!clockfile.is_open()) {
            cout << "Failed to open file" << endl;
        }
        clockfile.close();
        }
        // update system time to match the clock file's modified time
        int result = clock_settime(CLOCK_REALTIME, &ModifiedTime);
        if(result == 0){
            cout<< "updated system time to current time" << endl;
        }
        else{
            cout<< "failed to update system time" << endl;
        }
    }
    void update_system_time_on_startup() {
           cout << "hello" << endl;
};

int main() {
    TimeEvent timeEvent;
    timespec time;
    timespec_get(&time, TIME_UTC);
    cout << "hello" << endl;
    timeEvent.receive_time_event(time);
    auto lastModifiedTime = timeEvent.get_latest_clock_entry();
    boost::thread Thread(&TimeEvent::wait, &timeEvent); 
    // boost::thread Thread1(boost::bind(&TimeEvent::wait, &timeEvent));
    cout << "good" << endl;
    timeEvent.update_system_time_on_startup();
    Thread.join();
    return 0;
}

1 个解决方案

解决方案1
 1  2023-01-20 22:18:48

所以我想独立于 main() 运行 wait()

您可以通过在单独的线程中运行等待来实现。 当然你已经这样做了。 事实上，您已经可以在main中运行其他代码，您已经这样做了，尽管很少：

cout << "good" << endl;

这是在您的线程上运行wait时打印的。 一切都很好。 当然，如果你想做更多的事情，go 就可以了。 一旦你join() Thread你的 main 将阻塞直到 Thread 退出。

让我做一些我在代码审查期间发现的观察，然后给你一些关于后台线程正常关闭的想法。

首先是一些观察

您的程序行为与您的期望不符的原因之一是get_latest_clock_entry()中的未定义行为：

timespec get_latest_clock_entry() {
    std::cout << "hello" << std::endl;
    return {}; // TODO, no return is Undefined Behavior!
}

任何事情都可能发生，但依赖条件currentTime.tv_sec > ModifiedTime.tv_sec肯定是不可靠的。

此外，在动态调整时钟的系统中，基于时钟值等待可能不可靠，就像您的代码使用::clock_settime(CLOCK_REALTIME)的那样。 当然，正如所写的那样，代码将表现不稳定，因为您确实使用了具有不确定值的clock_settime （如前所述）。

在线程开始和您的update_system_time_on_startup之间也存在竞争条件。 目前，显然它什么都不做（但说“你好”），但一旦它做了更多事情（就像它说的那样），它就会（a）在没有同步的情况下触摸共享的 state（b）影响wait时间代码。

receive_time_event奇怪地忽略了参数。 那是故意的吗？ 为什么通过左值引用传递？ 它需要更新吗？

建议

您可能应该更好地解释您实际想要实现的目标。

假设你以某种方式试图同步不同的系统时钟，看起来像

if (currentTime.tv_sec > ModifiedTime.tv_sec)
    touch(clock_file);

旨在，每分钟一次：

  • 如果“我们的实时时钟”比“某个时钟条目？来自其他来源？”提前 1 秒，则更新 clock_file
  • 无条件地将我们的时钟设置为等于“其他来源”

已经与问题中的问题描述不符。 此外，您的等待代码应该

  1. 使用单调时钟来防止时钟变化时的错误
  2. 使用预先计算的截止日期，而不是盲目地将 60 秒添加到给定时间
  3. 不太关心UTC vs locatime

让我们回顾并简化一些其他代码：

static void touch(fs::path p) {
    create_directories(p.parent_path());
    fs::ofstream ofs(p);
    if (!ofs)
        throw std::runtime_error("Failed to create " + p.native());
}

static ::timespec getCurrentTime() {
    timespec currentTime;
    timespec_get(&currentTime, TIME_UTC);
    return currentTime;
}

void validate() {
    // std::cout << "hi" << std::endl;
    timespec currentTime  = getCurrentTime();
    timespec ModifiedTime = get_latest_clock_entry();

    if (currentTime.tv_sec > ModifiedTime.tv_sec)
        touch(clock_file);

    // update system time to match the clock file's modified time
    if (0 != clock_settime(CLOCK_REALTIME, &ModifiedTime))
        throw std::system_error(make_error_code(static_cast<std::errc>(errno)));
}

要消除竞争条件，只需将update_system_time_on_startup移动到timeEvent内。更好的是，将整个实例移动到线程内！

void synchronizationThread() {
    try {
        TimeEvent timeEvent;
        timeEvent.update_system_time_on_startup();
        timeEvent.wait();
    } catch (std::exception const& e) {
        std::cerr << "synchronizationThread error: " << e.what() << std::endl;
    }
}

int main() {
    boost::thread sync(synchronizationThread);

    sync.join();
}

如前所述，等待代码过于复杂（清理版本）：

void wait() {
    while (1) {
        std::cout << "start wait" << std::endl;
        ptime Now_Time    = boost::posix_time::second_clock::local_time(),
              update_Time = Now_Time + boost::posix_time::minutes(1);

        boost::posix_time::time_duration counter = update_Time - Now_Time;
        std::cerr << "Sleeping for " << counter << "\n";
        boost::this_thread::sleep(counter);
        boost::this_thread::sleep_for(60s);
        validate();
    }
}

它可能更简单，同时是等效的：

void wait() {
    while (1) {
        std::cout << "start wait" << std::endl;
        std::this_thread::sleep_for(60s);
        validate();
    }
}

请注意，我们现在不再需要posix_time并且不需要链接到 Boost Datetime 库。 事实上，我们可以用 std::thread 和 std::filesystem 替换 boost::thread 和 boost::filesystem 并且没有任何 boost 依赖。

当然，这是假设validate()不花时间，或者后面的validates()相隔 60s 以上也是可以的。 坦率地说，在时间同步听起来很重要的情况下，这听起来令人惊讶，所以我会写下我的意思，明确使用单调时钟：

void wait() {
    using Clock   = std::chrono::steady_clock; // monotonous!

    auto next_cycle = [start = Clock::now()] {
        auto deadline = start;
        while (deadline <= Clock::now())
            deadline += cycle_interval;
        std::this_thread::sleep_until(deadline);
        return true;
    };

    while (next_cycle()) {
        validate();
    }
}

显然定义合适的间隔如下：

constexpr auto cycle_interval = 60s;

现场演示

生活在 Coliru

#include <cassert>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <thread>

#include <sys/stat.h>
#include <time.h>

namespace fs = std::filesystem;
using namespace std::chrono_literals;

constexpr auto& clock_file     = "/home/saman/Desktop/clock";
constexpr auto& sync_file      = "/home/saman/Desktop/hi/hi/synchronized";
constexpr auto  cycle_interval = 5s; // 60s

class TimeEvent {
    static void touch(fs::path p) {
        create_directories(p.parent_path());
        std::ofstream ofs(p);
        if (!ofs)
            throw std::runtime_error("Failed to create " + p.native());
    }
    static ::timespec getCurrentTime() {
        timespec currentTime;
        timespec_get(&currentTime, TIME_UTC);
        return currentTime;
    }

  public:
    void receive_time_event(timespec /*time*/) {
        touch(clock_file);
        touch(sync_file);
    }

    timespec get_latest_clock_entry() { return getCurrentTime(); }

    void wait() {
        using Clock = std::chrono::steady_clock; // monotonous!

        auto next_cycle = [start = Clock::now()] {
            auto deadline = start;
            while (deadline <= Clock::now())
                deadline += cycle_interval;

            std::cout << "Waiting " << (deadline - Clock::now()) / 1ms << "ms" << std::endl;
            std::this_thread::sleep_until(deadline);
            return true;
        };

        while (next_cycle()) {
            validate();
        }
    }

    void validate() {
        std::cout << "validate()" << std::endl;
        timespec currentTime  = getCurrentTime();
        timespec ModifiedTime = get_latest_clock_entry();

        if (currentTime.tv_sec > ModifiedTime.tv_sec)
            touch(clock_file);

        {
            // I don't want to risk messing up my systemclock while doing the testing
            auto tie = [](timespec const& ts) { return std::tie(ts.tv_sec, ts.tv_nsec); };
            assert(tie(currentTime) <= tie(ModifiedTime));
        }

        // update system time to match the clock file's modified time
        if (0 != clock_settime(CLOCK_REALTIME, &ModifiedTime))
            throw std::system_error(make_error_code(static_cast<std::errc>(errno)));
    }

    void update_system_time_on_startup() {
        std::cout << "update_system_time_on_startup" << std::endl;
        receive_time_event(getCurrentTime());
    };
};

void synchronizationThread() {
    try {
        TimeEvent timeEvent;
        timeEvent.update_system_time_on_startup();
        timeEvent.wait();
    } catch (std::exception const& e) {
        std::cerr << "synchronizationThread error: " << e.what() << std::endl;
    }
}

int main() {
    std::jthread sync(synchronizationThread);

    for (int i = 0; i < 27; ++i) {
        std::this_thread::sleep_for(1s);
        std::cout << "." << std::flush;
    }
}

本地：

在此处输入图像描述

奖励：优雅关机

当然，您希望在合理的时间限制内正常关机：

生活在 Coliru

#include <atomic>
#include <cassert>
#include <condition_variable>
#include <filesystem>
#include <fstream>
#include <functional>
#include <iostream>
#include <mutex>
#include <thread>

#include <sys/stat.h>
#include <time.h>

namespace fs = std::filesystem;
using namespace std::chrono_literals;

constexpr auto& clock_file     = "/home/saman/Desktop/clock";
constexpr auto& sync_file      = "/home/saman/Desktop/hi/hi/synchronized";
constexpr auto  cycle_interval = 5s; // 60s

class TimeEvent {
    static void touch(fs::path p) {
        create_directories(p.parent_path());
        std::ofstream ofs(p);
        if (!ofs)
            throw std::runtime_error("Failed to create " + p.native());
    }
    static ::timespec getCurrentTime() {
        timespec currentTime;
        timespec_get(&currentTime, TIME_UTC);
        return currentTime;
    }

    using Clock = std::chrono::steady_clock; // monotonous clock
    Clock::time_point const start = Clock::now();
    std::mutex              mx;
    std::condition_variable cv;
    std::atomic_bool        shutdown_requested{false};

    bool next_cycle() {
        auto deadline = start;
        while (deadline <= Clock::now())
            deadline += cycle_interval;

        std::cout << "Waiting " << (deadline - Clock::now()) / 1ms << "ms" << std::endl;

        std::unique_lock<std::mutex> lk(mx);
        cv.wait_until(lk, deadline, [this] { return shutdown_requested.load(); });
        return !shutdown_requested;
    };

  public:
    void shutdown() {
        shutdown_requested = true;
        std::lock_guard<std::mutex> lk(mx);
        cv.notify_all();
    }

    void receive_time_event(timespec /*time*/) {
        touch(clock_file);
        touch(sync_file);
    }

    timespec get_latest_clock_entry() { return getCurrentTime(); }

    void wait() {
        try {
            update_system_time_on_startup(); // optionally?

            while (next_cycle()) {
                validate();
            }
        } catch (std::exception const& e) {
            std::cerr << "synchronizationThread error: " << e.what() << std::endl;
        }
    }

    void validate() {
        std::cout << "validate()" << std::endl;
        timespec currentTime  = getCurrentTime();
        timespec ModifiedTime = get_latest_clock_entry();

        if (currentTime.tv_sec > ModifiedTime.tv_sec)
            touch(clock_file);

        {
            // I don't want to risk messing up my systemclock while doing the testing
            auto tie = [](timespec const& ts) { return std::tie(ts.tv_sec, ts.tv_nsec); };
            assert(tie(currentTime) <= tie(ModifiedTime));
        }

        // update system time to match the clock file's modified time
        if (0 != clock_settime(CLOCK_REALTIME, &ModifiedTime))
            throw std::system_error(make_error_code(static_cast<std::errc>(errno)));
    }

    void update_system_time_on_startup() {
        std::cout << "update_system_time_on_startup" << std::endl;
        receive_time_event(getCurrentTime());
    };
};

int main() {
    TimeEvent    te;
    std::jthread sync(&TimeEvent::wait, &te);

    for (int i = 0; i < 27; ++i) {
        std::this_thread::sleep_for(1s);
        std::cout << "." << std::flush;
    }

    te.shutdown();
}

在此处输入图像描述

奖励 2：使用 Boost Thread 中断点

这样做的好处是将 TimeEvent 实例封装在线程中，从而消除了手动同步的需要。 缺点是需要 Boost Chrono、Boost System、Boost Thread（在我的示例中，还需要 Boost Filesystem，只是为了说明切换是多么容易）：

生活在 Coliru

#include <boost/chrono.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/thread.hpp>
#include <cassert>
#include <fstream>
#include <iostream>

#include <sys/stat.h>
#include <time.h>

namespace fs = boost::filesystem;

constexpr auto& clock_file     = "/home/saman/Desktop/clock";
constexpr auto& sync_file      = "/home/saman/Desktop/hi/hi/synchronized";
constexpr auto  cycle_interval = boost::chrono::seconds(5); // minutes(60)

class TimeEvent {
    static void touch(fs::path p) {
        create_directories(p.parent_path());
        fs::ofstream ofs(p);
        if (!ofs)
            throw std::runtime_error("Failed to create " + p.native());
    }
    static ::timespec getCurrentTime() {
        timespec currentTime;
        timespec_get(&currentTime, TIME_UTC);
        return currentTime;
    }

    using Clock = boost::chrono::steady_clock; // monotonous clock
    Clock::time_point const start = Clock::now();

    bool next_cycle() const {
        auto deadline = start;
        while (deadline <= Clock::now())
            deadline += cycle_interval;

        std::cout << "Waiting " << (deadline - Clock::now()) / boost::chrono::milliseconds(1) << "ms"
                  << std::endl;

        boost::this_thread::sleep_until(deadline);
        return true;
    };

  public:
    void shutdown() {
    }

    void receive_time_event(timespec /*time*/) {
        touch(clock_file);
        touch(sync_file);
    }

    timespec get_latest_clock_entry() { return getCurrentTime(); }

    void wait() {
        while (next_cycle()) {
            validate();
        }
    }

    void validate() {
        std::cout << "validate()" << std::endl;
        timespec currentTime  = getCurrentTime();
        timespec ModifiedTime = get_latest_clock_entry();

        if (currentTime.tv_sec > ModifiedTime.tv_sec)
            touch(clock_file);

        {
            // I don't want to risk messing up my systemclock while doing the testing
            auto tie = [](timespec const& ts) { return std::tie(ts.tv_sec, ts.tv_nsec); };
            assert(tie(currentTime) <= tie(ModifiedTime));
        }

        // update system time to match the clock file's modified time
        if (0 != clock_settime(CLOCK_REALTIME, &ModifiedTime))
            throw std::system_error(make_error_code(static_cast<std::errc>(errno)));
    }

    void update_system_time_on_startup() {
        std::cout << "update_system_time_on_startup" << std::endl;
        receive_time_event(getCurrentTime());
    };
};

void synchronizationThread() {
    try {
        TimeEvent timeEvent;
        timeEvent.update_system_time_on_startup();
        timeEvent.wait();
    } catch (std::exception const& e) {
        std::cerr << "synchronizationThread error: " << e.what() << std::endl;
    }
}

int main() {
    boost::thread sync(synchronizationThread);

    for (int i = 0; i < 27; ++i) {
        boost::this_thread::sleep_for(boost::chrono::seconds(1));
        std::cout << "." << std::flush;
    }

    if (sync.joinable()) {
        sync.interrupt();
        sync.join();
    }
}

您甚至可以更轻松地永远不会忘记打断和加入：

int main() {
    boost::thread sync(synchronizationThread);
    boost::thread_guard<boost::interrupt_and_join_if_joinable> guard(sync);

    for (int i = 0; i < 27; ++i) {
        boost::this_thread::sleep_for(boost::chrono::seconds(1));
        std::cout << "." << std::flush;
    }
}

暂无
暂无

声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

相关问题 C ++ MultiThreading块主线程 C ++ boost :: thread在主线程上执行代码？ 主线程死锁C++ c ++中“main”线程的id C ++新线程休眠主线程 在C ++中向主线程报告线程进度 C ++主线程通知线程通知主线程 理解c ++代码块 （C ++）是否必须使用main（）编写线程？ 主线程的C ++调用方法
相关标签
 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM