037 《Folly Chrono.h 权威指南》

                                
                                    

                            
1
                            
#include <folly/chrono/TimePoint.h>
                        

                            
2
                            
#include <folly/chrono/Clock.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            

                        

                            
5
                            
using namespace folly::chrono;
                        

                            
6
                            

                        

                            
7
                            
int main() {
                        

                            
8
                            
  // ① 使用 SystemClock 获取当前时间点
                        

                            
9
                            
  TimePoint<SystemClock> now = SystemClock::now();
                        

                            
10
                            
  std::cout << "Current SystemClock TimePoint: " << now.time_since_epoch().count() << std::endl;
                        

                            
11
                            

                        

                            
12
                            
  // ② 使用 SteadyClock 获取当前时间点
                        

                            
13
                            
  TimePoint<SteadyClock> steadyNow = SteadyClock::now();
                        

                            
14
                            
  std::cout << "Current SteadyClock TimePoint: " << steadyNow.time_since_epoch().count() << std::endl;
                        

                            
15
                            

                        

                            
16
                            
  // ③ 构造一个相对于纪元偏移 5 秒的 TimePoint (使用 SystemClock)
                        

                            
17
                            
  TimePoint<SystemClock> futureTime = TimePoint<SystemClock>(seconds(5));
                        

                            
18
                            
  std::cout << "Future SystemClock TimePoint (5 seconds from epoch): " << futureTime.time_since_epoch().count() << std::endl;
                        

                            
19
                            

                        

                            
20
                            
  return 0;
                        

                            
21
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
TimePoint<SystemClock> sysNow = SystemClock::now();
                        

                            
2
                            
std::cout << "SystemClock now: " << sysNow.time_since_epoch().count() << std::endl;
                        
                                
                            

                                
                                    

                            
1
                            
TimePoint<SteadyClock> steadyNow = SteadyClock::now();
                        

                            
2
                            
std::cout << "SteadyClock now: " << steadyNow.time_since_epoch().count() << std::endl;
                        
                                
                            

                                
                                    

                            
1
                            
TimePoint<HighResolutionClock> hiResNow = HighResolutionClock::now();
                        

                            
2
                            
std::cout << "HighResolutionClock now: " << hiResNow.time_since_epoch().count() << std::endl;
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/TimePoint.h>
                        

                            
2
                            
#include <folly/chrono/Clock.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            
#include <thread>
                        

                            
5
                            

                        

                            
6
                            
using namespace folly::chrono;
                        

                            
7
                            

                        

                            
8
                            
int main() {
                        

                            
9
                            
  // 使用 SteadyClock 测量代码执行时间
                        

                            
10
                            
  TimePoint<SteadyClock> start = SteadyClock::now();
                        

                            
11
                            
  std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟耗时操作
                        

                            
12
                            
  TimePoint<SteadyClock> end = SteadyClock::now();
                        

                            
13
                            
  Duration<SteadyClock> elapsed = end - start;
                        

                            
14
                            

                        

                            
15
                            
  std::cout << "Elapsed time using SteadyClock: " << elapsed.count() << " nanoseconds" << std::endl;
                        

                            
16
                            

                        

                            
17
                            
  // 使用 SystemClock 测量时间 (可能受到系统时间调整影响)
                        

                            
18
                            
  TimePoint<SystemClock> sysStart = SystemClock::now();
                        

                            
19
                            
  std::this_thread::sleep_for(std::chrono::milliseconds(100));
                        

                            
20
                            
  TimePoint<SystemClock> sysEnd = SystemClock::now();
                        

                            
21
                            
  Duration<SystemClock> sysElapsed = sysEnd - sysStart;
                        

                            
22
                            

                        

                            
23
                            
  std::cout << "Elapsed time using SystemClock: " << sysElapsed.count() << " nanoseconds" << std::endl;
                        

                            
24
                            

                        

                            
25
                            
  return 0;
                        

                            
26
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
TimePoint<SystemClock> now = SystemClock::now();
                        

                            
2
                            
TimePoint<SystemClock> future = now + seconds(10); // 10 秒后的时间点
                        
                                
                            

                                
                                    

                            
1
                            
TimePoint<SystemClock> now = SystemClock::now();
                        

                            
2
                            
TimePoint<SystemClock> past = now - minutes(1); // 1 分钟前的时间点
                        
                                
                            

                                
                                    

                            
1
                            
TimePoint<SteadyClock> start = SteadyClock::now();
                        

                            
2
                            
std::this_thread::sleep_for(std::chrono::milliseconds(500));
                        

                            
3
                            
TimePoint<SteadyClock> end = SteadyClock::now();
                        

                            
4
                            
Duration<SteadyClock> interval = end - start; // 计算时间间隔
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/TimePoint.h>
                        

                            
2
                            
#include <folly/chrono/Clock.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            

                        

                            
5
                            
using namespace folly::chrono;
                        

                            
6
                            

                        

                            
7
                            
int main() {
                        

                            
8
                            
  TimePoint<SystemClock> now = SystemClock::now();
                        

                            
9
                            
  std::cout << "Now: " << now.time_since_epoch().count() << std::endl;
                        

                            
10
                            

                        

                            
11
                            
  // 加法运算
                        

                            
12
                            
  TimePoint<SystemClock> futureTime = now + seconds(30);
                        

                            
13
                            
  std::cout << "30 seconds later: " << futureTime.time_since_epoch().count() << std::endl;
                        

                            
14
                            

                        

                            
15
                            
  // 减法运算
                        

                            
16
                            
  TimePoint<SystemClock> pastTime = now - minutes(5);
                        

                            
17
                            
  std::cout << "5 minutes ago: " << pastTime.time_since_epoch().count() << std::endl;
                        

                            
18
                            

                        

                            
19
                            
  // 时间点相减得到 Duration
                        

                            
20
                            
  Duration<SystemClock> diff = futureTime - now;
                        

                            
21
                            
  std::cout << "Time difference (futureTime - now): " << diff.count() << " nanoseconds" << std::endl;
                        

                            
22
                            

                        

                            
23
                            
  return 0;
                        

                            
24
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
这些单位实际上是类型别名，例如 `seconds` 通常是 `Duration<long long, std::ratio<1, 1>>` 的别名，表示以秒为单位，使用 `long long` 类型存储计数值。`std::ratio<1, 1>` 定义了秒的比例关系（1秒/1秒）。
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Duration.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
using namespace folly::chrono;
                        

                            
5
                            

                        

                            
6
                            
int main() {
                        

                            
7
                            
  // 使用不同的时间单位创建 Duration
                        

                            
8
                            
  Duration<seconds> fiveSeconds = seconds(5);
                        

                            
9
                            
  Duration<milliseconds> hundredMillis = milliseconds(100);
                        

                            
10
                            
  Duration<nanoseconds> oneNano = nanoseconds(1);
                        

                            
11
                            

                        

                            
12
                            
  std::cout << "5 seconds in nanoseconds: " << fiveSeconds.count() << std::endl;
                        

                            
13
                            
  std::cout << "100 milliseconds in nanoseconds: " << hundredMillis.count() << std::endl;
                        

                            
14
                            
  std::cout << "1 nanosecond in nanoseconds: " << oneNano.count() << std::endl;
                        

                            
15
                            

                        

                            
16
                            
  return 0;
                        

                            
17
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
auto dur1 = 5s;    // 5 秒
                        

                            
2
                            
auto dur2 = 100ms; // 100 毫秒
                        

                            
3
                            
auto dur3 = 1ns;   // 1 纳秒
                        
                                
                            

                                
                                    

                            
1
                            
Duration<seconds> dur4(15); // 15 秒
                        

                            
2
                            
Duration<milliseconds> dur5(250); // 250 毫秒
                        
                                
                            

                                
                                    

                            
1
                            
TimePoint<SteadyClock> start = SteadyClock::now();
                        

                            
2
                            
TimePoint<SteadyClock> end = SteadyClock::now();
                        

                            
3
                            
Duration<SteadyClock> dur6 = end - start;
                        
                                
                            

                                
                                    

                            
1
                            
Duration<nanoseconds> nanoDur = nanoseconds(1000000000);
                        

                            
2
                            
Duration<seconds> secDur = nanoDur; // 隐式转换：纳秒 -> 秒
                        

                            
3
                            
std::cout << "1 billion nanoseconds in seconds: " << secDur.count() << std::endl;
                        
                                
                            

                                
                                    

                            
1
                            
Duration<seconds> secDur2 = seconds(1);
                        

                            
2
                            
Duration<milliseconds> milliDur2 = convert_duration<milliseconds>(secDur2); // 显式转换：秒 -> 毫秒
                        

                            
3
                            
std::cout << "1 second in milliseconds: " << milliDur2.count() << std::endl;
                        

                            
4
                            

                        

                            
5
                            
Duration<milliseconds> milliDur3 = milliseconds(1500);
                        

                            
6
                            
Duration<seconds> secDur3 = convert_duration<seconds>(milliDur3); // 显式转换：毫秒 -> 秒 (可能丢失精度)
                        

                            
7
                            
std::cout << "1500 milliseconds in seconds: " << secDur3.count() << " (integer truncation)" << std::endl;
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Duration.h>
                        

                            
2
                            
#include <folly/chrono/Conv.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            

                        

                            
5
                            
using namespace folly::chrono;
                        

                            
6
                            

                        

                            
7
                            
int main() {
                        

                            
8
                            
  // 构造 Duration
                        

                            
9
                            
  auto dur1 = 2min; // 字面量
                        

                            
10
                            
  Duration<hours> dur2(0.5); // 构造函数
                        

                            
11
                            

                        

                            
12
                            
  std::cout << "2 minutes in seconds: " << convert_duration<seconds>(dur1).count() << std::endl;
                        

                            
13
                            
  std::cout << "0.5 hours in minutes: " << convert_duration<minutes>(dur2).count() << std::endl;
                        

                            
14
                            

                        

                            
15
                            
  // 显式转换
                        

                            
16
                            
  Duration<milliseconds> milliDur = milliseconds(2500);
                        

                            
17
                            
  Duration<seconds> secDur = convert_duration<seconds>(milliDur); // 显式转换，可能截断
                        

                            
18
                            
  std::cout << "2500 milliseconds in seconds: " << secDur.count() << std::endl;
                        

                            
19
                            

                        

                            
20
                            
  return 0;
                        

                            
21
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
auto dur1 = 1min;
                        

                            
2
                            
auto dur2 = 30s;
                        

                            
3
                            
auto sum = dur1 + dur2; // 1 分钟 + 30 秒 = 1 分 30 秒
                        

                            
4
                            
std::cout << "1 minute + 30 seconds = " << convert_duration<seconds>(sum).count() << " seconds" << std::endl;
                        
                                
                            

                                
                                    

                            
1
                            
auto dur3 = 2min;
                        

                            
2
                            
auto dur4 = 45s;
                        

                            
3
                            
auto diff = dur3 - dur4; // 2 分钟 - 45 秒 = 1 分 15 秒
                        

                            
4
                            
std::cout << "2 minutes - 45 seconds = " << convert_duration<seconds>(diff).count() << " seconds" << std::endl;
                        
                                
                            

                                
                                    

                            
1
                            
auto dur5 = 15s;
                        

                            
2
                            
auto multiplied = dur5 * 3; // 15 秒 * 3 = 45 秒
                        

                            
3
                            
std::cout << "15 seconds * 3 = " << (dur5 * 3).count() << " seconds" << std::endl;
                        
                                
                            

                                
                                    

                            
1
                            
auto dur6 = 1min;
                        

                            
2
                            
auto divided = dur6 / 2; // 1 分钟 / 2 = 30 秒
                        

                            
3
                            
std::cout << "1 minute / 2 = " << convert_duration<seconds>(divided).count() << " seconds" << std::endl;
                        

                            
4
                            

                        

                            
5
                            
auto dur7 = 2min;
                        

                            
6
                            
auto dur8 = 30s;
                        

                            
7
                            
auto ratio = dur7 / dur8; // 2 分钟 / 30 秒 = 4 (比例)
                        

                            
8
                            
std::cout << "2 minutes / 30 seconds = " << ratio << " (ratio)" << std::endl;
                        
                                
                            

                                
                                    

                            
1
                            
auto dur9 = 75s;
                        

                            
2
                            
auto dur10 = 1min;
                        

                            
3
                            
auto remainder = dur9 % dur10; // 75 秒 % 1 分钟 = 15 秒
                        

                            
4
                            
std::cout << "75 seconds % 1 minute = " << remainder.count() << " seconds" << std::endl;
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Duration.h>
                        

                            
2
                            
#include <folly/chrono/Conv.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            

                        

                            
5
                            
using namespace folly::chrono;
                        

                            
6
                            

                        

                            
7
                            
int main() {
                        

                            
8
                            
  auto dur1 = 1min;
                        

                            
9
                            
  auto dur2 = 30s;
                        

                            
10
                            

                        

                            
11
                            
  // 加法
                        

                            
12
                            
  auto sum = dur1 + dur2;
                        

                            
13
                            
  std::cout << "Sum: " << convert_duration<seconds>(sum).count() << " seconds" << std::endl;
                        

                            
14
                            

                        

                            
15
                            
  // 减法
                        

                            
16
                            
  auto diff = dur1 - dur2;
                        

                            
17
                            
  std::cout << "Difference: " << convert_duration<seconds>(diff).count() << " seconds" << std::endl;
                        

                            
18
                            

                        

                            
19
                            
  // 乘法
                        

                            
20
                            
  auto product = dur1 * 2;
                        

                            
21
                            
  std::cout << "Product: " << convert_duration<minutes>(product).count() << " minutes" << std::endl;
                        

                            
22
                            

                        

                            
23
                            
  // 除法 (Duration / int)
                        

                            
24
                            
  auto quotientDur = dur1 / 2;
                        

                            
25
                            
  std::cout << "Quotient (Duration): " << convert_duration<seconds>(quotientDur).count() << " seconds" << std::endl;
                        

                            
26
                            

                        

                            
27
                            
  // 除法 (Duration / Duration)
                        

                            
28
                            
  auto quotientRatio = dur1 / dur2;
                        

                            
29
                            
  std::cout << "Quotient (Ratio): " << quotientRatio << std::endl;
                        

                            
30
                            

                        

                            
31
                            
  // 取模
                        

                            
32
                            
  auto remainder = seconds(75) % minutes(1);
                        

                            
33
                            
  std::cout << "Remainder: " << remainder.count() << " seconds" << std::endl;
                        

                            
34
                            

                        

                            
35
                            
  return 0;
                        

                            
36
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Clock.h>
                        

                            
2
                            
#include <folly/chrono/TimePoint.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            
#include <thread>
                        

                            
5
                            

                        

                            
6
                            
using namespace folly::chrono;
                        

                            
7
                            

                        

                            
8
                            
int main() {
                        

                            
9
                            
  // 使用 SystemClock 记录事件时间
                        

                            
10
                            
  TimePoint<SystemClock> eventTime = SystemClock::now();
                        

                            
11
                            
  std::cout << "Event occurred at SystemClock time: " << eventTime.time_since_epoch().count() << std::endl;
                        

                            
12
                            

                        

                            
13
                            
  // 使用 SteadyClock 测量代码执行时间
                        

                            
14
                            
  TimePoint<SteadyClock> startTime = SteadyClock::now();
                        

                            
15
                            
  std::this_thread::sleep_for(std::chrono::milliseconds(200));
                        

                            
16
                            
  TimePoint<SteadyClock> endTime = SteadyClock::now();
                        

                            
17
                            
  Duration<SteadyClock> elapsedTime = endTime - startTime;
                        

                            
18
                            
  std::cout << "Elapsed time using SteadyClock: " << elapsedTime.count() << " nanoseconds" << std::endl;
                        

                            
19
                            

                        

                            
20
                            
  // 使用 HighResolutionClock 获取高精度时间戳 (示例，实际精度取决于平台)
                        

                            
21
                            
  TimePoint<HighResolutionClock> hiResTime = HighResolutionClock::now();
                        

                            
22
                            
  std::cout << "HighResolutionClock time: " << hiResTime.time_since_epoch().count() << std::endl;
                        

                            
23
                            

                        

                            
24
                            
  return 0;
                        

                            
25
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Clock.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
using namespace folly::chrono;
                        

                            
5
                            

                        

                            
6
                            
int main() {
                        

                            
7
                            
  std::cout << "SystemClock precision (period): " << ClockTraits<SystemClock>::period::num << "/" << ClockTraits<SystemClock>::period::den << " seconds" << std::endl;
                        

                            
8
                            
  std::cout << "SteadyClock precision (period): " << ClockTraits<SteadyClock>::period::num << "/" << ClockTraits<SteadyClock>::period::den << " seconds" << std::endl;
                        

                            
9
                            
  std::cout << "HighResolutionClock precision (period): " << ClockTraits<HighResolutionClock>::period::num << "/" << ClockTraits<HighResolutionClock>::period::den << " seconds" << std::endl;
                        

                            
10
                            
  return 0;
                        

                            
11
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Clock.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            
#include <ratio>
                        

                            
4
                            

                        

                            
5
                            
using namespace folly::chrono;
                        

                            
6
                            

                        

                            
7
                            
template <typename Clock>
                        

                            
8
                            
void printClockPrecision() {
                        

                            
9
                            
  using period = typename Clock::period;
                        

                            
10
                            
  std::cout << typeid(Clock).name() << " precision: 1/" << period::den / period::num << " seconds" << std::endl;
                        

                            
11
                            
}
                        

                            
12
                            

                        

                            
13
                            
int main() {
                        

                            
14
                            
  printClockPrecision<SystemClock>();
                        

                            
15
                            
  printClockPrecision<SteadyClock>();
                        

                            
16
                            
  printClockPrecision<HighResolutionClock>();
                        

                            
17
                            
  return 0;
                        

                            
18
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Interval.h>
                        

                            
2
                            
#include <folly/chrono/Clock.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            

                        

                            
5
                            
using namespace folly::chrono;
                        

                            
6
                            

                        

                            
7
                            
int main() {
                        

                            
8
                            
  TimePoint<SystemClock> start = SystemClock::now();
                        

                            
9
                            
  std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
                        

                            
10
                            
  TimePoint<SystemClock> end = SystemClock::now();
                        

                            
11
                            

                        

                            
12
                            
  // ① 使用起始和结束 TimePoint 创建 Interval
                        

                            
13
                            
  Interval<SystemClock> interval1(start, end);
                        

                            
14
                            
  std::cout << "Interval 1 duration: " << interval1.duration().count() << " nanoseconds" << std::endl;
                        

                            
15
                            

                        

                            
16
                            
  // ② 使用起始 TimePoint 和 Duration 创建 Interval
                        

                            
17
                            
  Interval<SystemClock> interval2(start, seconds(3)); // 从 start 开始，持续 3 秒
                        

                            
18
                            
  std::cout << "Interval 2 duration: " << interval2.duration().count() << " nanoseconds" << std::endl;
                        

                            
19
                            

                        

                            
20
                            
  return 0;
                        

                            
21
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Interval.h>
                        

                            
2
                            
#include <folly/chrono/Clock.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            

                        

                            
5
                            
using namespace folly::chrono;
                        

                            
6
                            

                        

                            
7
                            
int main() {
                        

                            
8
                            
  TimePoint<SystemClock> start = SystemClock::now();
                        

                            
9
                            
  TimePoint<SystemClock> mid = start + seconds(1);
                        

                            
10
                            
  TimePoint<SystemClock> end = start + seconds(3);
                        

                            
11
                            

                        

                            
12
                            
  Interval<SystemClock> interval(start, end);
                        

                            
13
                            

                        

                            
14
                            
  std::cout << "Interval start: " << interval.start().time_since_epoch().count() << std::endl;
                        

                            
15
                            
  std::cout << "Interval end: " << interval.end().time_since_epoch().count() << std::endl;
                        

                            
16
                            
  std::cout << "Interval duration: " << interval.duration().count() << " nanoseconds" << std::endl;
                        

                            
17
                            

                        

                            
18
                            
  // 判断时间点是否在 Interval 内
                        

                            
19
                            
  std::cout << "Interval contains start: " << interval.contains(start) << std::endl;
                        

                            
20
                            
  std::cout << "Interval contains mid: " << interval.contains(mid) << std::endl;
                        

                            
21
                            
  std::cout << "Interval contains end: " << interval.contains(end) << std::endl;
                        

                            
22
                            
  std::cout << "Interval contains (end + 1 second): " << interval.contains(end + seconds(1)) << std::endl;
                        

                            
23
                            

                        

                            
24
                            
  // Interval 移动
                        

                            
25
                            
  Interval<SystemClock> shiftedInterval = interval.shifted(seconds(2));
                        

                            
26
                            
  std::cout << "Shifted interval start: " << shiftedInterval.start().time_since_epoch().count() << std::endl;
                        

                            
27
                            
  std::cout << "Shifted interval end: " << shiftedInterval.end().time_since_epoch().count() << std::endl;
                        

                            
28
                            

                        

                            
29
                            
  return 0;
                        

                            
30
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/HighResolutionClock.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            
#include <vector>
                        

                            
4
                            
#include <numeric>
                        

                            
5
                            

                        

                            
6
                            
using namespace folly::chrono;
                        

                            
7
                            

                        

                            
8
                            
int main() {
                        

                            
9
                            
  auto start = HighResolutionClock::now(); // ① 获取开始时间点 (Get start time point)
                        

                            
10
                            

                        

                            
11
                            
  // 模拟一段需要计时的代码 (Simulate a piece of code to be timed)
                        

                            
12
                            
  std::vector<int> numbers(1000000);
                        

                            
13
                            
  std::iota(numbers.begin(), numbers.end(), 1);
                        

                            
14
                            
  long long sum = std::accumulate(numbers.begin(), numbers.end(), 0LL);
                        

                            
15
                            

                        

                            
16
                            
  auto end = HighResolutionClock::now();   // ② 获取结束时间点 (Get end time point)
                        

                            
17
                            
  auto duration = end - start;             // ③ 计算时间间隔 (Calculate time duration)
                        

                            
18
                            

                        

                            
19
                            
  std::cout << "Sum: " << sum << std::endl;
                        

                            
20
                            
  std::cout << "代码执行耗时 (Code execution time): " << duration << std::endl; // ④ 输出时间间隔 (Output time duration)
                        

                            
21
                            
  std::cout << "代码执行耗时 (毫秒) (Code execution time (milliseconds)): " << to_milliseconds(duration) << "ms" << std::endl; // ⑤ 转换为毫秒并输出 (Convert to milliseconds and output)
                        

                            
22
                            

                        

                            
23
                            
  return 0;
                        

                            
24
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Duration.h>
                        

                            
2
                            
#include <folly/chrono/sleep.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            

                        

                            
5
                            
using namespace folly::chrono;
                        

                            
6
                            

                        

                            
7
                            
int main() {
                        

                            
8
                            
  std::cout << "开始休眠 (Start sleeping)..." << std::endl;
                        

                            
9
                            

                        

                            
10
                            
  sleep_for(1_s); // ① 休眠 1 秒 (Sleep for 1 second)
                        

                            
11
                            
  std::cout << "休眠 1 秒后 (After sleeping for 1 second)..." << std::endl;
                        

                            
12
                            

                        

                            
13
                            
  sleep_for(milliseconds(500)); // ② 休眠 500 毫秒 (Sleep for 500 milliseconds)
                        

                            
14
                            
  std::cout << "休眠 500 毫秒后 (After sleeping for 500 milliseconds)..." << std::endl;
                        

                            
15
                            

                        

                            
16
                            
  sleep_for(microseconds(100)); // ③ 休眠 100 微秒 (Sleep for 100 microseconds)
                        

                            
17
                            
  std::cout << "休眠 100 微秒后 (After sleeping for 100 microseconds)..." << std::endl;
                        

                            
18
                            

                        

                            
19
                            
  return 0;
                        

                            
20
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/HighResolutionClock.h>
                        

                            
2
                            
#include <folly/chrono/SystemClock.h>
                        

                            
3
                            
#include <folly/chrono/SteadyClock.h>
                        

                            
4
                            
#include <iostream>
                        

                            
5
                            
#include <iomanip> // for std::put_time
                        

                            
6
                            
#include <ctime>   // for std::localtime, std::tm
                        

                            
7
                            

                        

                            
8
                            
using namespace folly::chrono;
                        

                            
9
                            

                        

                            
10
                            
int main() {
                        

                            
11
                            
  auto systemClockTimePoint = SystemClock::now(); // ① 获取 SystemClock 时间戳 (Get SystemClock timestamp)
                        

                            
12
                            
  auto steadyClockTimePoint = SteadyClock::now(); // ② 获取 SteadyClock 时间戳 (Get SteadyClock timestamp)
                        

                            
13
                            
  auto highResolutionClockTimePoint = HighResolutionClock::now(); // ③ 获取 HighResolutionClock 时间戳 (Get HighResolutionClock timestamp)
                        

                            
14
                            

                        

                            
15
                            
  std::cout << "SystemClock 时间戳 (SystemClock Timestamp): " << systemClockTimePoint << std::endl;
                        

                            
16
                            
  std::cout << "SteadyClock 时间戳 (SteadyClock Timestamp): " << steadyClockTimePoint << std::endl;
                        

                            
17
                            
  std::cout << "HighResolutionClock 时间戳 (HighResolutionClock Timestamp): " << highResolutionClockTimePoint << std::endl;
                        

                            
18
                            

                        

                            
19
                            
  // 将 SystemClock 时间戳转换为可读格式 (Convert SystemClock timestamp to readable format)
                        

                            
20
                            
  std::time_t t = SystemClock::to_time_t(systemClockTimePoint); // ④ 转换为 time_t (Convert to time_t)
                        

                            
21
                            
  std::tm tm = *std::localtime(&t); // ⑤ 转换为 tm 结构体 (Convert to tm struct)
                        

                            
22
                            
  std::cout << "SystemClock 时间戳 (可读格式) (SystemClock Timestamp (readable format)): " << std::put_time(&tm, "%Y-%m-%d %H:%M:%S") << std::endl; // ⑥ 格式化输出 (Formatted output)
                        

                            
23
                            

                        

                            
24
                            

                        

                            
25
                            
  return 0;
                        

                            
26
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Duration.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
using namespace folly::chrono;
                        

                            
5
                            

                        

                            
6
                            
int main() {
                        

                            
7
                            
  Duration<double, std::ratio<1, 1>> seconds_duration(1.5); // ① 1.5 秒 (1.5 seconds)
                        

                            
8
                            
  Duration<double, std::ratio<1, 1000>> milliseconds_duration = to_milliseconds(seconds_duration); // ② 秒转毫秒 (Seconds to milliseconds)
                        

                            
9
                            
  Duration<double, std::ratio<1, 1000000>> microseconds_duration = to_microseconds(seconds_duration); // ③ 秒转微秒 (Seconds to microseconds)
                        

                            
10
                            
  Duration<double, std::ratio<1, 1000000000>> nanoseconds_duration = to_nanoseconds(seconds_duration); // ④ 秒转纳秒 (Seconds to nanoseconds)
                        

                            
11
                            

                        

                            
12
                            
  std::cout << "原始 Duration (秒) (Original Duration (seconds)): " << seconds_duration.count() << "s" << std::endl;
                        

                            
13
                            
  std::cout << "转换为毫秒 (Converted to milliseconds): " << milliseconds_duration.count() << "ms" << std::endl;
                        

                            
14
                            
  std::cout << "转换为微秒 (Converted to microseconds): " << microseconds_duration.count() << "us" << std::endl;
                        

                            
15
                            
  std::cout << "转换为纳秒 (Converted to nanoseconds): " << nanoseconds_duration.count() << "ns" << std::endl;
                        

                            
16
                            

                        

                            
17
                            
  return 0;
                        

                            
18
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Duration.h>
                        

                            
2
                            
#include <folly/chrono/Units.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            

                        

                            
5
                            
using namespace folly::chrono;
                        

                            
6
                            

                        

                            
7
                            
// ① 自定义时间单位 "帧" (Define custom time unit "frame")
                        

                            
8
                            
using frames = duration_units<int, std::ratio<1, 60>, unit_name<"frame">, unit_abbr<"fr">>;
                        

                            
9
                            

                        

                            
10
                            
// ② 自定义字面量 "_fr" (Define custom literal "_fr")
                        

                            
11
                            
constexpr frames operator"" _fr(unsigned long long count) {
                        

                            
12
                            
  return frames{static_cast<int>(count)};
                        

                            
13
                            
}
                        

                            
14
                            

                        

                            
15
                            
int main() {
                        

                            
16
                            
  frames frame_duration = 10_fr; // ③ 使用自定义字面量 (Use custom literal)
                        

                            
17
                            
  milliseconds ms_duration = to_milliseconds(frame_duration); // ④ 转换为毫秒 (Convert to milliseconds)
                        

                            
18
                            

                        

                            
19
                            
  std::cout << "帧 Duration (frames Duration): " << frame_duration.count() << "fr" << std::endl;
                        

                            
20
                            
  std::cout << "转换为毫秒 (Converted to milliseconds): " << ms_duration.count() << "ms" << std::endl;
                        

                            
21
                            

                        

                            
22
                            
  return 0;
                        

                            
23
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/SystemClock.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            
#include <iomanip> // for std::put_time
                        

                            
4
                            
#include <ctime>   // for std::localtime, std::tm
                        

                            
5
                            

                        

                            
6
                            
using namespace folly::chrono;
                        

                            
7
                            

                        

                            
8
                            
int main() {
                        

                            
9
                            
  auto timePoint = SystemClock::now();
                        

                            
10
                            

                        

                            
11
                            
  // 格式化为 ISO 8601 格式 (Formatted as ISO 8601 format)
                        

                            
12
                            
  std::cout << "ISO 8601 格式 (ISO 8601 format): " << format_iso8601_local(timePoint) << std::endl;
                        

                            
13
                            

                        

                            
14
                            
  // 格式化为自定义格式 (Formatted as custom format)
                        

                            
15
                            
  std::time_t t = SystemClock::to_time_t(timePoint);
                        

                            
16
                            
  std::tm tm = *std::localtime(&t);
                        

                            
17
                            
  std::cout << "自定义格式 (Custom format): " << std::put_time(&tm, "%Y年%m月%d日 %H时%M分%S秒") << std::endl; // ① 使用 std::put_time 格式化 (Use std::put_time for formatting)
                        

                            
18
                            

                        

                            
19
                            
  return 0;
                        

                            
20
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Duration.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            
#include <iomanip> // for std::setprecision
                        

                            
4
                            

                        

                            
5
                            
using namespace folly::chrono;
                        

                            
6
                            

                        

                            
7
                            
int main() {
                        

                            
8
                            
  Duration<double> duration = 1.23456_s;
                        

                            
9
                            

                        

                            
10
                            
  // 默认格式输出 (Default format output)
                        

                            
11
                            
  std::cout << "默认格式 (Default format): " << duration << std::endl;
                        

                            
12
                            

                        

                            
13
                            
  // 设置精度格式化输出 (Formatted output with precision)
                        

                            
14
                            
  std::cout << "设置精度格式 (Formatted with precision): " << std::fixed << std::setprecision(3) << duration << std::endl; // ① 使用 std::setprecision 设置精度 (Use std::setprecision for precision)
                        

                            
15
                            

                        

                            
16
                            
  return 0;
                        

                            
17
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/SystemClock.h>
                        

                            
2
                            
#include <folly/chrono/Duration.h>
                        

                            
3
                            
#include <iostream>
                        

                            
4
                            

                        

                            
5
                            
using namespace folly::chrono;
                        

                            
6
                            

                        

                            
7
                            
int main() {
                        

                            
8
                            
  auto now = SystemClock::now();
                        

                            
9
                            
  Duration<int, std::ratio<3600>> one_hour(1); // ① 1 小时 Duration (1 hour Duration)
                        

                            
10
                            

                        

                            
11
                            
  auto one_hour_later = now + one_hour; // ② 时间点加 Duration (TimePoint plus Duration)
                        

                            
12
                            
  auto one_hour_earlier = now - one_hour; // ③ 时间点减 Duration (TimePoint minus Duration)
                        

                            
13
                            
  auto duration_since_earlier = now - one_hour_earlier; // ④ 时间点减时间点，得到 Duration (TimePoint minus TimePoint, get Duration)
                        

                            
14
                            

                        

                            
15
                            
  std::cout << "当前时间 (Current time): " << now << std::endl;
                        

                            
16
                            
  std::cout << "一小时后 (One hour later): " << one_hour_later << std::endl;
                        

                            
17
                            
  std::cout << "一小时前 (One hour earlier): " << one_hour_earlier << std::endl;
                        

                            
18
                            
  std::cout << "从一小时前到现在的时间间隔 (Duration from one hour earlier to now): " << duration_since_earlier << std::endl;
                        

                            
19
                            

                        

                            
20
                            
  return 0;
                        

                            
21
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
#include <folly/chrono/Duration.h>
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
using namespace folly::chrono;
                        

                            
5
                            

                        

                            
6
                            
int main() {
                        

                            
7
                            
  Duration<double> duration1 = 1.5_s;
                        

                            
8
                            
  Duration<double> duration2 = 0.5_s;
                        

                            
9
                            

                        

                            
10
                            
  auto sum_duration = duration1 + duration2; // ① Duration 加法 (Duration addition)
                        

                            
11
                            
  auto diff_duration = duration1 - duration2; // ② Duration 减法 (Duration subtraction)
                        

                            
12
                            
  auto product_duration = duration1 * 2;     // ③ Duration 乘法 (Duration multiplication)
                        

                            
13
                            
  auto quotient_duration = duration1 / 2;    // ④ Duration 除法 (Duration division)
                        

                            
14
                            
  auto ratio = duration1 / duration2;        // ⑤ Duration 除法，得到比例 (Duration division, get ratio)
                        

                            
15
                            

                        

                            
16
                            
  std::cout << "Duration 1: " << duration1 << std::endl;
                        

                            
17
                            
  std::cout << "Duration 2: " << duration2 << std::endl;
                        

                            
18
                            
  std::cout << "Duration 加法 (Duration addition): " << sum_duration << std::endl;
                        

                            
19
                            
  std::cout << "Duration 减法 (Duration subtraction): " << diff_duration << std::endl;
                        

                            
20
                            
  std::cout << "Duration 乘法 (Duration multiplication): " << product_duration << std::endl;
                        

                            
21
                            
  std::cout << "Duration 除法 (Duration division): " << quotient_duration << std::endl;
                        

                            
22
                            
  std::cout << "Duration 比例 (Duration ratio): " << ratio << std::endl;
                        

                            
23
                            

                        

                            
24
                            
  return 0;
                        

                            
25
                            
}