系统时间往前改动导致std::condition_variable wait_for失效问题

原创 已于 2023-06-09 19:16:36 修改 · 2.1k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

于 2023-06-09 17:51:56 首次发布
修改系统时间可能导致wait_for超时功能失效，特别是Linux环境下，GCC版本大于等于10且glibc大于等于2.30时影响显著。小幅时间调整（如ntp同步）对不敏感的程序可能无碍，但大幅调整需更换编译环境。Bug报告确认了此问题。

系统时间往前改动，直接导致wait_for超时失效。看标准库代码用的steady_clock，理论上不会出现这个问题。

vs2022 + windows10

往前修改时间对程序行为没有影响。

linux + gcc

发现gcc版本和glibc版本对wait_for都有影响，gcc >=10 且 glibc >= 2.30 才会对程序行为没有影响。

影响到底多大

如果向前时间 改动不大，比如只有1~3秒（通常是ntp时间同步导致）。
你的程序对时间不敏感的，其实可以不管，等向前修改的时间 ”走完“，程序行为又会正常了。
否则，只能替换编译环境。

如果向前时间 改动较大，则只能替换编译环境了。

bug论证

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=41861，也和测试结果 相印证了

条件变量 condition_variable：wait、wait_for、wait_until
zfjBIT的专栏
10-18 4262
c++ 线程条件变量 wait、wait_for、wait_until
c++11并发与多线程
电气小学僧的博客
03-03 1253
视频连接 并发 早期计算机是单核cpu，只能同时执行一个任务，所以就快速切换任务主体，实现“同时”做多个任务，造成一个并发的假象； 后来多核cpu的计算机出现了，可以实现真正的并行任务执行；即支持硬件并发； 使用并发主要是为了挺高性能 线程和进程 每一个可执行程序就对应一个进程； 每一个进程里只能包含一个主线程，并且这个主线程随着可执行程序的启动而启动； 比如c的main函数就是一个主线程，程序启动时，先启动main部分 并行的实现方式 可以使用多进程实现并行，或者多线程实现并行。 进程之间：在同一电脑上使
标准库条件变量等待时间受系统时间影响
pes2020的博客
10-12 2326
std::condition_variable bug ​ wait_until受系统时间修改导致等待不准确 (gcc version 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04) ) ​ 代码中使用了std::condition_variable 来实现信号量，但是当修改了系统时间后会导致信号量提前(往后改系统时间)延后触发(往前改系统时间)，究其原因是信号量的wait_for 或 wait_until接口以系统时钟作为标准导致。** 实例测试代码 采用usleep std
C++ 多线程同步condition_variable的用法
咸鱼爱幻想的博客
02-26 3346
多线程并发有两大需求：互斥和同步(等待-触发)。互斥是因为线程间存在共享数据，等待-触发是因为线程间存在依赖关系。互斥最常见，一般通过互斥锁unique_lock(mutex)形式实现。同步，由于线程间需要按照预定的先后次序顺序进行，就要用到condition_variable和condition_variable_any。互斥锁条件变量中也要用到，互斥锁是条件变量的应用前提，必须先学会基础的unique_lock(mutex)互斥锁应用。
pthread_cond_wait执行失败
明潮的BLOG
11-06 2138
Printf("execute result:%d",pthread_cond_wait(&reply_cond, &reply_mutex)); 执行没有返回结果，日志也没有打印 查询linux doc查到如下结果： Description The pthread_cond_timedwait() and pthread_cond_wait() functions shall b
C++语法学习笔记四十九：condition_variable、wait
哲学天空的博客
08-28 700
实例代码： // #include <iostream> #include <vector> #include <thread> #include <mutex> #include <list> #include <map> #include <string> #include <condition_variable> using namespace std; class A{ public: //把
C++ std::condition_variable::wait
qq_34999565的博客
10-20 6767
std::condition_variable提供了两个等待函数：wait()和wait_for().条件变量是需要和一个互斥锁mutex配合使用，调用wait（）之前应该先获得mutex，当线程调用 wait() 后将被阻塞，直到另外某个线程调用 notify_one或notify_all唤醒了当前线程。 std::condition_variable::wait 1. void wait( std::unique_lockstd::mutex& lock ); 2 template< cl
C++ 并发编程实战 学习笔记
myc13381的博客
07-07 1583
C++ 并发编程实战学习记录
深入原理64式：32 C和C++知识总结
qingyuanluofeng的专栏
11-21 713
目标: 整理C和C++知识，主要包含如下内容: 1、数组 2、字符串 3、结构体、共用体与枚举 4、运算符及其优先级 5、C预处理器与内存管理 6、函数 7、指针与引用 8、类 9、多态与虚函数表 10、泛型，模板与元编程 11、STL 12、原理 13、智能指针 13、makefile与链接库 14、effective C++ 15、线程，锁与队列 第一部分 数组 1 如何定义数组的引用?...
《Boost程序完全开发指南》
JUSTACES 的博客
01-27 9238
1.3开发环境 由于Boost大量使用了C++高级特性（如模板偏特化、ADL），因此不是所有的编译器都 能够很好地支持Boost。 在VC集成环境中使用嵌入工程编译的方式需要定义宏BOOST_ALL_NO_LIB或者 BOOST_XXX_NO_LIB(XXX是某个库的名称)，以指示BOOST库不要使用自动链接功能。 如果在debug版工程，不要忘记在Preprocesso
c++ 多线程学习入门篇精讲（1）
dangforever的博客
03-21 1088
目录 基本概念C++中的多线程示例1：创建线程并执行函数 示例2：传递参数给线程函数示例3：使用Lambda表达式 线程同步什么是线程同步？为什么需要线程同步？（1）数据竞争（Data Race）的例子（2）不一致状态（Inconsistent State）的例子数据竞争和不一致状态的区别 尝试手动加锁解决问题手动实现锁的问题C++ 中的线程同步机制示例4：使用std::mutex进行线程同步（补充）关于emplace_back与 push_back 的区别（补充）关于基于范围的for循环（补充）关于aut
【随笔记】C++ condition_variable 陷阱
lovemengx的博客
09-30 1742
这种问题只有在系统时间发生变化的时候才会出现，例如搭配 NTP 更新功能，硬件还未同步时间时，一般在 1993 年，此时使用了 wait_for() 这类接口等待 10 秒，结果在 10 秒内被 ntp 同步更新了时间到 2023，那么时间生效的一瞬间，wait_for() 就会直接被唤醒，且返回的结果是超时唤醒。通过 std::condition_variable 来实现超时等待，会受到系统时间变化的影响，系统时间倒退修改就会导致延后唤醒，系统时间提前将会导致提前被唤醒，返回结果仍为超时。
【Windows +VS2019 +STL】处理std::condition_variable::wait_for返回值不准的问题
H_O_W_E的专栏
10-26 1223
Windows下执行std::condition_variable的wait_for(),实际超时了，但是返回值说没超时，不可靠。解决方法是..
记录多线程中condition_variable 的条件与wait+wait_for；多线程池的概念与实现；我遇到的问题；
weixin_74236594的博客
03-05 526
分析：在consume 中的std::unique_locklck(mtx)是自动上锁的，原因是在与unique_lock 的作用，他与wait 进行贴合；而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。wait_for(lck, std::chrono::seconds(1)) == std::cv_status::timeout估计应该是延迟一秒，求解答》》》更快的响应，当达到线程上线的时候，线程池会让后来的进程进行等待，当没有进程命令的时候不用进行等待；
c++中std::condition_variable、wait_for() 和 wait_until()的使用详解和示例
qq_36812406的博客
07-02 1132
生产者-消费者模型；等待某一条件满足（例如缓冲区不为空）；实现线程阻塞、解阻塞机制；控制线程顺序执行。wait_for是等待相对时间，适合写成固定超时逻辑；wait_until是等待绝对时间点，适合调度定时任务；永远使用谓词版本（）来避免虚假唤醒；返回值可以判断是超时还是正常唤醒。
C++ std::condition_variable wait() wait_for() 区别 怎么用 实例
热门推荐
软件工程小施同学 的专栏
10-09 2万+
一、std::condition_variable 是条件变量。 二、wait() 当 std::condition_variable 对象的某个 wait 函数被调用的时候，它使用 std::unique_lock(通过 std::mutex) 来锁住当前线程。当前线程会一直被阻塞，直到另外一个线程在相同的 std::condition_variable 对象上调用了 notification 函数来唤醒当前线程。 首先我们来看一个简单的例子 #include <iostrea..
详解Condition的await和signal等待通知机制
weixin_60257072的博客
03-16 1399
任何一个java对象都天然继承于Object类，在线程间实现通信的往往会应用到Object的几个方法，比如wait(),wait(long timeout),wait(long timeout, int nanos)与notify(),notifyAll()几个方法实现等待/通知机制，同样的， 在java Lock体系下依然会有同样的方法实现等待/通知机制。从整体上来看。两者除了在使用方式上不同外，在。
当前的类设计存在缺陷，因为这些表达式可能会使用到其他表达式，当前的类设计没有考虑到其他表达式型号 MAT SURFACE L P W R BS Shape D L1 BRAND DESCRIPTIoN_CN GG CODE IsShowXBR IsShowXL XBR XL D8-13-A2 "标准-SKD11相当" "无" 50~56~60~63~70~71~80~90~100 3.00^9.97 3.00^7.97 0.15^W/2 0^360 "X"~"R"~"L"~"K"~"O"~"H"~"J" 8 13 DAYTON 冲头 WHK X2~X84~X88~无 "false"~"true" "false"~"true" 13_0^if(IsShowXL == "true")(XL-18)else(L-18) L_L-10^L #pragma region expEditor class ExcelFieldTypeClassifier { public: enum ExpressionType { Fixed, // 固定值，不能改动的，如 DAYTON List, // 可以拆分成列表的，带“~” Range, // 可以拆分范围的，带“^” Condition, // 条件表达式，包含 if/else MaxType // 枚举上限 }; public: // 构造函数（从 NXString 转换） ExcelFieldTypeClassifier(NXOpen::NXString nxStr) : m_expression(nxStr.GetLocaleText()) { initType(); } // 构造函数（直接传入 string） ExcelFieldTypeClassifier(const std::string& str) : m_expression(str) { initType(); } // 默认析构 ~ExcelFieldTypeClassifier() { } // 获取原始表达式 const std::string& getExpression() const { return m_expression; } // 获取类型枚举 ExpressionType getType() const { return m_type; } // 获取类型名称（字符串形式） std::string getTypeName() const { switch(m_type) { case Fixed: return "Fixed"; case List: return "List"; case Range: return "Range"; case Condition: return "Condition"; default: return "Unknown"; } } private: std::string m_expression; // 存储原始表达式 ExpressionType m_type; // 解析出的类型 // 内部初始化函数，用于识别类型 void initType() { if(m_expression.find("if") != std::string::npos || m_expression.find("else") != std::string::npos) { m_type = Condition; } else if(m_expression.empty()) { m_type = Fixed; } else if(m_expression.find('~') != std::string::npos) { m_type = List; } else if(m_expression.find('^') != std::string::npos) { m_type = Range; } else { m_type = Fixed; } } }; class ExcelFieldType { public: virtual ~ExcelFieldType() { } // 只读访问接口 const std::string& getExpression() const { return m_expression; } virtual std::string getTypeName() const = 0; virtual void parse() = 0; protected: // 构造函数受保护，防止直接实例化 ExcelFieldType(const std::string& expr) : m_expression(expr) { } private: std::string m_expression; // 私有成员，子类不能直接访问 }; class FixedExcelField: public ExcelFieldType { public: FixedExcelField(const std::string& expr) : ExcelFieldType(expr) { } // 调用基类构造函数 ~FixedExcelField() { } std::string getTypeName() const override { return "Fixed"; } void parse() override { // 固定值无需解析 } }; class ListExcelField: public ExcelFieldType { public: ListExcelField(const std::string& expr) : ExcelFieldType(expr) { parse(); // 构造时自动解析 } ~ListExcelField() { } std::string getTypeName() const override { return "List"; } void parse() override { const std::string& expr = getExpression(); size_t start = 0,pos; m_list.clear(); while((pos = expr.find('~',start)) != std::string::npos) { m_list.push_back(expr.substr(start,pos - start)); start = pos + 1; } if(start < expr.size()) { m_list.push_back(expr.substr(start)); } } // 提供接口获取解析结果 const std::vector<std::string>& getParsedList() const { return m_list; } private: std::vector<std::string> m_list; }; class RangeExcelField: public ExcelFieldType { public: RangeExcelField(const std::string& expr) : ExcelFieldType(expr) { parse(); // 构造时自动解析 } ~RangeExcelField() { } std::string getTypeName() const override { return "Range"; } void parse() override { const std::string& expr = getExpression(); size_t pos = expr.find('^'); if(pos != std::string::npos) { std::istringstream issLow(expr.substr(0,pos)); std::istringstream issHigh(expr.substr(pos + 1)); issLow >> m_low; issHigh >> m_high; } else { m_low = m_high = 0.0; } } // 提供接口获取解析后的范围值 double getLow() const { return m_low; } double getHigh() const { return m_high; } private: double m_low; double m_high; }; class ConditionExcelField: public ExcelFieldType { public: ConditionExcelField(const std::string& expr) : ExcelFieldType(expr) { parse(); // 构造时自动解析 } ~ConditionExcelField() { } std::string getTypeName() const override { return "Condition"; } void parse() override { const std::string& expr = getExpression(); size_t start = expr.find('^'); if(start != std::string::npos) { m_condition = expr.substr(start + 1); } else { m_condition = ""; } } // 提供接口获取解析后的条件表达式 const std::string& getCondition() const { return m_condition; } private: std::string m_condition; }; class ExcelFieldTypeFactory { public: static ExcelFieldType* createField(const ExcelFieldTypeClassifier& classifier) { switch(classifier.getType()) { case ExcelFieldTypeClassifier::Fixed: return new FixedExcelField(classifier.getExpression()); case ExcelFieldTypeClassifier::List: return new ListExcelField(classifier.getExpression()); case ExcelFieldTypeClassifier::Range: return new RangeExcelField(classifier.getExpression()); case ExcelFieldTypeClassifier::Condition: return new ConditionExcelField(classifier.getExpression()); default: return NULL; } } }; #pragma endregion
最新发布
07-09
题目重述 你指出了当前类设计的一个重要缺陷：即表达式之间可能存在依赖关系，当前设计未能处理这些依赖关系。例如，某些表达式可能引用其他表达式的值，如 `13_0^if(IsShowXL == "true")(XL-18)else(L-18)` 和 `L_L-10^L`。 --- 详解 为了处理表达式之间的依赖关系，我们需要引入一些机制来支持表达式之间的引用和计算。以下是改进方案的详细说明： ### ✅ 改进方案 1. **引入表达式上下文管理**：创建一个全局或局部的表达式上下文对象，用于存储所有已解析的表达式及其结果，以便后续表达式可以引用这些结果。 2. **扩展 `parse()` 方法**：在解析过程中，允许表达式引用其他表达式的值。这可以通过在解析时传递上下文对象来实现。 3. **支持表达式求值**：引入 `evaluate()` 方法，在解析完成后可以计算表达式的最终值，包括条件表达式的求值。 ### ✅ 实现细节 #### 1. 引入表达式上下文管理 创建一个 `ExpressionContext` 类，用于存储和检索表达式结果。 ```cpp #include <unordered_map> #include <memory> class ExpressionContext { public: // 添加表达式结果 void addResult(const std::string& name, const std::string& result) { results_[name] = result; } // 获取表达式结果 std::string getResult(const std::string& name) const { auto it = results_.find(name); if (it != results_.end()) { return it->second; } return ""; } private: std::unordered_map<std::string, std::string> results_; }; ``` #### 2. 修改基类和子类 基类 `ExcelFieldType` 需要引入 `evaluate()` 方法，并传递 `ExpressionContext` 对象。 ```cpp class ExcelFieldType { public: virtual ~ExcelFieldType() {} const std::string& getExpression() const { return m_expression; } virtual std::string getTypeName() const = 0; virtual void parse() = 0; virtual std::string evaluate(ExpressionContext& context) = 0; protected: ExcelFieldType(const std::string& expr) : m_expression(expr) {} private: std::string m_expression; }; ``` #### 3. 更新子类 每个子类都需要实现 `evaluate()` 方法，并根据表达式类型进行适当处理。特别地，`ConditionExcelField` 和其他涉及表达式引用的类需要处理依赖关系。 ```cpp class FixedExcelField : public ExcelFieldType { public: FixedExcelField(const std::string& expr) : ExcelFieldType(expr) {} std::string getTypeName() const override { return "Fixed"; } void parse() override { // 固定值无需解析 } std::string evaluate(ExpressionContext& /*context*/) override { return getExpression(); } }; class ListExcelField : public ExcelFieldType { public: ListExcelField(const std::string& expr) : ExcelFieldType(expr) { parse(); } std::string getTypeName() const override { return "List"; } void parse() override { const std::string& expr = getExpression(); size_t start = 0, pos; m_list.clear(); while ((pos = expr.find('~', start)) != std::string::npos) { m_list.push_back(expr.substr(start, pos - start)); start = pos + 1; } if (start < expr.size()) { m_list.push_back(expr.substr(start)); } } std::string evaluate(ExpressionContext& /*context*/) override { std::stringstream ss; for (const auto& item : m_list) { ss << item << "~"; } if (!m_list.empty()) { ss.seekp(-1, ss.cur); // 移除最后一个多余的 ~ } return ss.str(); } private: std::vector<std::string> m_list; }; class RangeExcelField : public ExcelFieldType { public: RangeExcelField(const std::string& expr) : ExcelFieldType(expr) { parse(); } std::string getTypeName() const override { return "Range"; } void parse() override { const std::string& expr = getExpression(); size_t pos = expr.find('^'); if (pos != std::string::npos) { std::istringstream issLow(expr.substr(0, pos)); std::istringstream issHigh(expr.substr(pos + 1)); issLow >> m_low; issHigh >> m_high; } else { m_low = m_high = 0.0; } } std::string evaluate(ExpressionContext& /*context*/) override { return std::to_string(m_low) + "^" + std::to_string(m_high); } private: double m_low; double m_high; }; class ConditionExcelField : public ExcelFieldType { public: ConditionExcelField(const std::string& expr) : ExcelFieldType(expr) { parse(); } std::string getTypeName() const override { return "Condition"; } void parse() override { const std::string& expr = getExpression(); size_t start = expr.find('^'); if (start != std::string::npos) { m_condition = expr.substr(start + 1); } else { m_condition = ""; } } std::string evaluate(ExpressionContext& context) override { if (!m_condition.empty()) { // 简单的条件求值示例，实际情况可能更复杂 if (m_condition.find("IsShowXL == \"true\"") != std::string::npos) { std::string xl = context.getResult("XL"); std::string l = context.getResult("L"); if (xl != "") { double xlValue = std::stod(xl); return std::to_string(xlValue - 18); } else if (l != "") { double lValue = std::stod(l); return std::to_string(lValue - 18); } } } return ""; } private: std::string m_condition; }; ``` #### 4. 工厂类更新 在创建对象时，传递上下文对象以供 `evaluate()` 方法使用。 ```cpp class ExcelFieldTypeFactory { public: static ExcelFieldType* createField(const ExcelFieldTypeClassifier& classifier) { switch (classifier.getType()) { case ExcelFieldTypeClassifier::Fixed: return new FixedExcelField(classifier.getExpression()); case ExcelFieldTypeClassifier::List: return new ListExcelField(classifier.getExpression()); case ExcelFieldTypeClassifier::Range: return new RangeExcelField(classifier.getExpression()); case ExcelFieldTypeClassifier::Condition: return new ConditionExcelField(classifier.getExpression()); default: return nullptr; } } }; ``` #### 5. 使用示例 ```cpp int main() { // 示例表达式 std::string expressions[] = { "DAYTON", "\"X\"~\"R\"~\"L\"", "0.15^W/2", "13_0^if(IsShowXL == \"true\")(XL-18)else(L-18)", "L_L-10^L" }; ExpressionContext context; // 解析并评估表达式 for (const auto& expr : expressions) { ExcelFieldTypeClassifier classifier(expr); ExcelFieldType* field = ExcelFieldTypeFactory::createField(classifier); if (field) { field->parse(); std::string result = field->evaluate(context); // 存储结果以便后续表达式引用 context.addResult(classifier.getTypeName(), result); std::cout << "表达式: \"" << field->getExpression() << "\", 类型: " << field->getTypeName() << ", 结果: " << result << std::endl; delete field; } } return 0; } ``` --- 知识点（列出该代码中遇到的知识点） | 知识点 | 描述 | |--------|------| | **表达式上下文管理** | 使用 `ExpressionContext` 管理表达式及其结果，支持表达式间的引用和计算。 | | **多态与虚函数** | 子类实现基类的虚函数接口（如 `evaluate()`），实现统一调用。 | | **字符串解析与求值** | 使用 `find`, `substr`, `istringstream` 等方法解析字符串，并在 `evaluate()` 中计算最终结果。 | --- 通过引入表达式上下文管理机制，你可以处理表达式之间的依赖关系，并确保在求值时正确引用其他表达式的结果。这使得整个解析和求值过程更加健壮和灵活。如果你有更多具体需求或问题，请继续提问 😊
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值