C++11 std::chrono库详解

最新推荐文章于 2025-08-26 15:52:00 发布
转载 最新推荐文章于 2025-08-26 15:52:00 发布 · 708 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://www.cnblogs.com/zlshmily/p/10058427.html

本文详细介绍了C++11及以后版本中的chrono库，它用于处理时间间隔、时钟和时间点。chrono库的核心包括duration、clocks和timepoints。duration类模板表示时间间隔，其单位可以使用std::ratio进行定义，如纳米、微秒、毫秒等。文章还列举了一些预定义的比率，并提供了chrono库在实际编程中的应用示例。

https://www.cnblogs.com/zlshmily/p/10058427.html

https://blog.youkuaiyun.com/albertsh/article/details/105468687?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control

https://www.cnblogs.com/-citywall123/p/12623266.html

https://jingyan.baidu.com/article/63acb44aac1df421fcc17eff.html

https://blog.youkuaiyun.com/bladelyer/article/details/7180932

https://www.runoob.com/cprogramming/c-function-ctime.html

chrono 的概况
头文件 #include <chrono>
命名空间std::chrono
这个库从 C++11 引入标准之后，每个版本都有所修改，不过核心内容变化不是太大，他定义了三种主要类型，分别是 duration、clocks 和 time points，以及围绕这些类型的一些工具函数和衍生的定义。

chrono 的核心内容
duration
这个模板类用来表示时间间隔，我们知道时间的基本单位是秒，这个类的对象所表示的时间间隔也是以秒为单位的，它的定义如下：

template<class Rep, class Period = std::ratio<1>>
class duration;

Rep 表示一种数值类型，用来描述周期 Period 的数值类型，比如可以是 int、float 等，而 Period 的类型是std::ratio，同样是一个模板类，实际表示的是一个有理数，像100、0、1/1000（千分之一）等等。

在 std 这个命名空间下有很多已经定义好的有理数，可以举几个常见的头文件<ratio>中的例子:

nano    std::ratio<1, 1000000000>   // 十亿分之一
micro   std::ratio<1, 1000000>      // 百万分之一
milli   std::ratio<1, 1000>         // 千分之一
centi   std::ratio<1, 100>          // 百分之一
deci    std::ratio<1, 10>           // 十分之一
deca    std::ratio<10, 1>           // 十
hecto   std::ratio<100, 1>          // 百
kilo    std::ratio<1000, 1>         // 千

http://www.voidcn.com/article/p-hcmcjcum-bac.html

再也不被时间束缚：C++ stdchrono时间库全面解析
Lion_Long的博客
10-22 1548
这是一篇介绍C++ std::chrono时间库的全面文章。在现代软件开发中，时间处理是一个重要的部分，而std::chrono时间库提供了丰富的功能和灵活的接口来处理时间相关的操作，使得开发者能够更好地控制和管理时间。 本文首先介绍了std::chrono时间库的核心概念，包括时钟、时间点和时间间隔。其中，时钟作为时间的源头，提供了基准和刻度；时间点表示特定时钟上的一个时间；时间间隔表示一段时间的表示。
std::chrono特性详解
漫步者
01-15 533
std::chrono是c++11版本引入的时间库。该特性提供了一些关于时间的基本操作。为什么需要引入这个时间库呢？
[C++]C++ std::chrono库使用
FL1768317420的博客
02-28 2797
我们的生活在时间的流逝中不断推进，这个自然的过程在C++中被封装在了这个类中。我们如同航海者使用指南针导航一样，可以借助在编程的海洋中导航。是一个代表系统广泛使用的实时钟的类。它表示当前的墙上时间，从中可以获得当前时间，也可以在时间点上执行算术运算。（时间点）可以被视为一个特殊的"时间戳"，它表示自纪元以来的时间量。纪元是指定的起点时间，对于来说，纪元通常是1970年1月1日午夜。在这个定义中，我们可以看出time_point。
c++11 日期和时间工具-（std::chrono）
m0_60274660的博客
06-30 3869
std::chrono是C++11引入的日期时间处理库，其中包含3种时钟：定义于头文件
std::chrono获取当前秒级/毫秒级/微秒级/纳秒级时间戳
hulinhulin的专栏
09-23 1630
C++使用std::chrono获取当前秒级/毫秒级/微秒级/纳秒级时间戳
C++，std::chrono 详解
汽车电子软件领域知识分享
08-23 2058
std::chrono 是 C++11 引入的一个库，用于处理日期和时间。它提供了一套丰富的类和函数，允许开发者以高精度（通常是纳秒级）来测量时间间隔、表示时间点、以及进行时间的算术运算。下面是对 std::chrono 库中一些关键组件的详细解释。
c++ chrono头文件含义
HJQD777的博客
06-05 686
在C++中，<chrono>是一个标准库头文件，用于处理时间相关的操作，包括时间点时间间隔和时钟。它提供了一套强大的时间处理功能，支持高精度的时间测量、时间间隔的计算以及时间点的表示。
C++11 std::shared_ptr总结与使用示例代码详解
08-19
C++11 std::shared_ptr总结与使用示例代码详解 std::shared_ptr是C++11中引入的一种智能指针，主要用于自动管理资源的生命周期。下面是std::shared_ptr的总结和使用示例代码详解： 一、智能指针的用途 std::...
C++11中std::future的具体使用方法
12-20
在C++11标准库中，`std::future`是一个重要的工具，用于处理异步编程。它提供了一种方式来获取在另一个线程或者异步操作中计算的结果，确保了线程安全的数据访问。`std::future`的核心特性是它引用的共享状态是唯一...
C++线程库std::thread和std::async的用法详解
程序猿老樊的博客
05-26 1611
C++作为一门强大的系统编程语言，提供了多种并发编程工具，使得开发者可以充分利用多核处理器的性能。C++11标准引入了新的线程库，包括std::thread和std::async，为开发高效并发应用提供了强大支持。下面我将std::thread和std::async的用法及其原理做一个归纳总结，希望对大家有帮助。
【C++标准库】std::chrono
m0_57168310的博客
11-21 3338
C++ 给我们封装好了不同的时间段类型，我们知道typedef作用，给类起别名。类minutes 就是 duration= 29 bits, ratio>。所以创建时间段对象，可以直接用 minutes 对象名//就可以得到一个20分钟的对象。所以，我们除了可以用std::chrono::duration自己指定一个时间段类型，还可以用标准库中内置的 minutes,seconds时间段类型。上面有一些成员属性，以及函数，有C++基础的应该都能看懂。
std的时间函数——chrono
qq_45721740的博客
07-22 945
/ 微微微// 飞秒// 皮秒// 纳秒// 微秒// 毫秒// centi：百分之一// deci：十分之一// deci：十倍// hecto：百倍// 千// 兆// 吉// 太// 拍// 百亿亿上述输出结果，在我的电脑上 system_clock和high_resolution_clock是相同的，都是从1970年1月1日0时0分0秒开始的，以纳秒为单位的结果。而steady_clock则是从上次开机到现在递增增加的时间结果(这里我的电脑是这样的，
标准库头文件：chrono
zhuikefeng的博客
03-09 1314
1.常用操作 2.常用变量 chrono::nanoseconds //纳秒 chrono::microseconds //微秒 chrono::milliseconds //毫秒 chrono::seconds //秒 chrono::minutes //分 chrono::hours //小时 chrono::days //天 chrono::w...
std::chrono 计时库使用方法
weixin_54476027的博客
08-26 392
本文介绍了C++11标准库中的std::chrono计时功能，用于替代传统的clock()计时方法。该库提供高精度的时间测量能力，支持毫秒、微秒、纳秒等多种时间单位。通过示例代码展示了如何使用high_resolution_clock获取时间点，计算代码执行时间差，并用duration_cast转换为指定单位输出。这种方法特别适合性能测试场景，可灵活选择不同时间精度测量程序运行耗时。
std::chrono时间相关
小虾米就是我喽
10-01 836
#define _XTIME_NSECS_PER_TICK 100 #define _XTIME_TICKS_PER_TIME_T (long long)10000000 时钟 system_clock steady_clock high_resolution_clock typedef steady_clock high_resolution_clock; chrono::system_cl...
C++ std::chrono库使用指南 (实现C++ 获取日期,时间戳,计时等功能)
热门推荐
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-14 1万+
C++ std::chrono库使用指南 (实现C++ 获取日期,时间戳,计时等功能)
【C++】头文件chrono
m0_61629312的博客
10-16 1019
2023年10月16日，周一晚上当前我只是简单的了解了一下chrono以后可能会深入了解chrono并更新文章。
[C++] C++11 std::chrono库
selfsongs
07-27 389
C++11 std::chrono库Durations持续时间类Time points 时间点Clocks时钟 来自C++11 std::chrono库详解 chrono是一个time library, 源于boost，现在已经是C++标准。 头文件 #include<chrono> 名称空间 std::chrono命名空间里 chrono是一个模版库，使用简单，功能强大，只需要理解三个概念：duration、time_point、clock Durations持续时间类 std::chr
c++11 std::stread join()
最新发布
09-18
<think> 我们被要求介绍C++11中std::thread的join()方法。根据引用内容，我们需要注意以下几点： 1. join()方法用于等待线程完成执行。 2. 调用join()之前必须检查线程是否可join（通过joinable()方法）。 3. 不可join的情况包括：默认构造的线程对象、已经被移动的线程对象、已经调用过join()或detach()的线程对象。 下面我们将详细解释join()方法，包括其作用、使用注意事项和示例代码。 ### 一、`std::thread::join()` 方法的作用 - 当调用 `join()` 时，当前线程（通常是主线程或调用者线程）会阻塞，直到被调用的线程执行完成。 - 一旦线程执行完毕，调用 `join()` 的线程会继续执行。 - 调用 `join()` 后，线程对象不再关联任何线程（即变成不可join的状态），并且可以安全销毁。 ### 二、使用 `join()` 的注意事项 1. **只能对可join的线程调用`join()`** 以下情况线程不可join（调用`join()`会抛出`std::system_error`异常）： - 默认构造的`std::thread`对象（没有关联任何线程函数） - 线程已被移动（所有权转移） - 已经调用过`join()`或`detach()` 2. **必须检查`joinable()`** 在调用`join()`前务必检查： ```cpp std::thread t([]{ /* 任务 */ }); if (t.joinable()) { t.join(); } ``` 3. **避免遗漏`join()`导致程序终止** 如果线程对象在析构时仍可join（即未调用`join()`或`detach()`），则程序会调用`std::terminate()`终止。因此务必确保每个线程在销毁前被正确处理。 ### 三、代码示例 ```cpp #include <iostream> #include <thread> #include <chrono> void worker_task() { std::cout << "Worker thread started\n"; std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作 std::cout << "Worker thread finished\n"; } int main() { // 创建并启动线程 std::thread t(worker_task); // 主线程继续执行其他任务 std::cout << "Main thread is waiting for worker...\n"; // 等待工作线程结束（阻塞） if (t.joinable()) { t.join(); // 正确：等待线程完成 } std::cout << "Main thread continues after join\n"; return 0; } ``` #### 输出结果： ``` Main thread is waiting for worker... Worker thread started Worker thread finished Main thread continues after join ``` ### 四、`join()` 与 `detach()` 的选择 - **`join()`**：需要等待线程结果时使用（同步） - **`detach()`**：让线程在后台运行（分离），调用后线程对象不再管理该线程（不可再join） ### 五、常见错误 1. **重复调用`join()`** ```cpp t.join(); t.join(); // 抛出std::system_error ``` 2. **忘记调用`join()`或`detach()`** ```cpp { std::thread t(worker_task); } // 作用域结束，t析构时仍可join -> 程序终止 ``` ### 六、最佳实践 - 使用RAII包装线程，确保自动释放： ```cpp class ThreadGuard { public: explicit ThreadGuard(std::thread& t) : t_(t) {} ~ThreadGuard() { if (t_.joinable()) { t_.join(); // 或根据需求选择detach() } } // 禁止复制 ThreadGuard(const ThreadGuard&) = delete; ThreadGuard& operator=(const ThreadGuard&) = delete; private: std::thread& t_; }; // 使用示例 std::thread t(worker_task); ThreadGuard guard(t); ``` §§相关问题§§ 1. `std::thread::detach()`的使用场景有哪些？ 2. 如何处理多个线程的同步等待？ 3. C++11中还有哪些线程管理机制？ [^1]: 默认构造、已移动或已结束的线程对象不可join [^2]: 遗漏`join()`或`detach()`会导致程序终止 [^3]: 重复调用`join()`会抛出异常 </think> ### C++11 `std::thread::join()` 方法详解 #### 一、核心作用 `std::thread::join()` 是线程同步的关键方法，主要功能是： 1. **阻塞当前线程**（通常为主线程），直到目标线程执行完毕 2. **回收线程资源**，确保线程对象安全销毁 3. **同步线程生命周期**，防止线程访问已销毁的资源 ```cpp std::thread t([]{ std::cout << "Worker thread running\n"; }); t.join(); // 主线程在此阻塞，等待t结束 std::cout << "Main thread continues\n"; ``` #### 二、使用前提：`joinable()` 检查 调用 `join()` 前必须验证线程是否可连接，否则会抛出 `std::system_error` 异常： ```cpp if (t.joinable()) { // 必须检查！ t.join(); } ``` ##### 不可 `join` 的三种情况： 1. **默认构造的线程对象**（未关联线程函数） ```cpp std::thread t1; // 默认构造 t1.joinable(); // 返回 false ``` 2. **已被移动的线程对象**（所有权转移） ```cpp std::thread t2(worker_func); std::thread t3 = std::move(t2); // t2 所有权转移 t2.joinable(); // 返回 false ``` 3. **已执行过 `join()` 或 `detach()`** ```cpp t3.join(); t3.joinable(); // 返回 false ``` #### 三、未正确处理的风险 若线程对象析构时仍可连接（未调用 `join()` 或 `detach()`），会触发 `std::terminate()` 导致程序终止： ```cpp { std::thread t(worker_func); } // 作用域结束，t 析构时仍 joinable -> 程序崩溃！ ``` #### 四、与 `detach()` 的区别 | 方法 | 阻塞调用方 | 资源回收时机 | 线程控制权 | |-----------|------------|--------------------|------------| | `join()` | 是 | 调用时立即回收 | 保持关联 | | `detach()`| 否 | 线程结束时自动回收 | 放弃关联 | ```cpp std::thread t(background_task); t.detach(); // 主线程继续执行，不等待t ``` #### 五、典型应用场景 1. **等待结果返回** ```cpp int result; std::thread t([&]{ result = compute(); }); t.join(); std::cout << result; // 安全访问结果 ``` 2. **资源有序释放** ```cpp auto* res = new Resource(); std::thread t([res]{ use(res); delete res; // 在线程内释放 }); t.join(); ``` 3. **多阶段任务同步** ```cpp std::thread stage1(task1); stage1.join(); std::thread stage2(task2); // 确保 stage1 完成 ``` #### 六、最佳实践 1. **RAII 封装自动管理** ```cpp class ThreadGuard { public: explicit ThreadGuard(std::thread& t) : t_(t) {} ~ThreadGuard() { if(t_.joinable()) t_.join(); } // 禁止复制 private: std::thread& t_; }; std::thread t(task); ThreadGuard guard(t); // 析构时自动 join ``` 2. **避免主线程意外退出** ```cpp int main() { std::thread t(long_running_task); // ... 可能抛异常的代码 if (t.joinable()) t.join(); // 异常安全处理 } ``` > ⚠️ **关键原则**：每个 `std::thread` 对象在销毁前必须调用 `join()` 或 `detach()` 之一[^1][^3]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值