0. 概述

為了檢查是否存在系統(tǒng)時間跳變，本文使用C++實現(xiàn)了一個簡單的高精度時間日志記錄小程序。該程序能夠每隔指定時間（默認40毫秒）記錄一次系統(tǒng)時間到文件中，并具備以下功能：

1. 自定義時間間隔和文件名：通過命令行參數(shù)設(shè)置時間間隔和輸出文件名，默認值為40毫秒和timestamps.txt。
2. 高精度定時：采用std::chrono::steady_clock和sleep_until確保時間間隔的準確性，避免std::this_thread::sleep_for帶來的時間漂移。
3. 緩存隊列：使用線程安全的隊列緩存時間戳，減少頻繁的文件I/O操作。
4. 日志輪轉(zhuǎn)：當日志文件大小超過100MB時，自動進行日志輪轉(zhuǎn)。
5. 時間跳變檢測：使用[TIME_JUMP]標記日志中發(fā)生的時間跳變（即后續(xù)時間戳小于前一個時間戳的情況）。
   默認僅記錄跳變前后的10個時間戳，避免日志文件中充斥過多正常的時間記錄，突出異常事件。

1. 代碼實現(xiàn)

1.1. 線程安全隊列（ThreadSafeQueue）

實現(xiàn)了一個簡單的線程安全隊列類ThreadSafeQueue，使用std::mutex和std::condition_variable來確保并發(fā)訪問的安全性。

// Thread-safe queue for storing timestamps
class ThreadSafeQueue {
public:// Push a new timestamp into the queuevoid push(const std::string& value) {std::lock_guard<std::mutex> lock(mtx_);queue_.push(value);cv_.notify_one();}// Retrieve and clear all timestamps from the queuestd::queue<std::string> popAll() {std::lock_guard<std::mutex> lock(mtx_);std::queue<std::string> temp;std::swap(temp, queue_);return temp;}private:std::queue<std::string> queue_;std::mutex mtx_;std::condition_variable cv_;
};

1.2. 獲取當前時間的字符串表示

使用gettimeofday獲取系統(tǒng)當前時間，并將其格式化為字符串，精確到微秒。

// Function to get the current time as a formatted string
std::string getCurrentTimeString() {struct timeval tv;gettimeofday(&tv, nullptr);struct tm* tm_info = localtime(&tv.tv_sec);char buffer[64];strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", tm_info);// Append microsecondschar currentTime[100];snprintf(currentTime, sizeof(currentTime), "%s.%06ld", buffer, tv.tv_usec);return std::string(currentTime);
}

1.3. 文件大小獲取

使用stat函數(shù)獲取指定文件的大小，以便在日志輪轉(zhuǎn)時進行判斷。

// Function to get the size of a file in bytes
std::size_t getFileSize(const std::string& filename) {struct stat stat_buf;int rc = stat(filename.c_str(), &stat_buf);return rc == 0 ? stat_buf.st_size : 0;
}

1.4. 時間戳解析

將時間戳字符串解析為自紀元以來的微秒數(shù)，方便進行時間比較以檢測時間跳變。

// Function to parse timestamp string to microseconds since epoch
uint64_t parseTimestamp(const std::string& timestamp_str) {struct tm tm_info;int microseconds = 0;// Split the timestamp into datetime and microsecondssize_t dot_pos = timestamp_str.find('.');if (dot_pos == std::string::npos) {// If no microseconds part, parse as isif (strptime(timestamp_str.c_str(), "%Y-%m-%d %H:%M:%S", &tm_info) == nullptr) {return 0;}} else {std::string datetime_str = timestamp_str.substr(0, dot_pos);std::string micro_str = timestamp_str.substr(dot_pos + 1);// Parse datetime partif (strptime(datetime_str.c_str(), "%Y-%m-%d %H:%M:%S", &tm_info) == nullptr) {return 0;}// Parse microseconds parttry {microseconds = std::stoi(micro_str);} catch (...) {microseconds = 0;}}time_t seconds = mktime(&tm_info);if (seconds == -1) {return 0;}uint64_t total_microseconds = static_cast<uint64_t>(seconds) * 1000000 + microseconds;return total_microseconds;
}

1.5. 主函數(shù)實現(xiàn)

主函數(shù)負責解析命令行參數(shù)，啟動生產(chǎn)者和消費者線程，并控制程序的運行時間和日志輪轉(zhuǎn)。

int main(int argc, char* argv[]) {// Default valuesint interval_ms = 40; // Default interval of 40 millisecondsstd::string filename = "timestamps.txt"; // Default filenameint run_time_seconds = 3600; // Default run time of 1 hour (3600 seconds)const std::size_t max_file_size = 100 * 1024 * 1024; // 100MB// Parse command-line argumentsfor(int i = 1; i < argc; ++i) {std::string arg = argv[i];if((arg == "-i" || arg == "--interval") && i + 1 < argc) {interval_ms = std::atoi(argv[++i]);if(interval_ms <= 0) {std::cerr << "Invalid interval. Using default value of 40 milliseconds." << std::endl;interval_ms = 40;}}else if((arg == "-f" || arg == "--file") && i + 1 < argc) {filename = argv[++i];}else if((arg == "-t" || arg == "--time") && i + 1 < argc) {run_time_seconds = std::atoi(argv[++i]);if(run_time_seconds <= 0) {std::cerr << "Invalid run time. Using default value of 3600 seconds (1 hour)." << std::endl;run_time_seconds = 3600;}}else if(arg == "-h" || arg == "--help") {std::cout << "Usage: " << argv[0] << " [options]\n"<< "Options:\n"<< "  -i, --interval <milliseconds>    Set the time interval, default is 40 milliseconds\n"<< "  -f, --file <filename>            Set the output filename, default is timestamps.txt\n"<< "  -t, --time <seconds>             Set the run time in seconds, default is 3600 seconds (1 hour)\n"<< "  -h, --help                       Show this help message\n";return 0;}else {std::cerr << "Unknown argument: " << arg << "\nUse -h or --help to see available options." << std::endl;return 1;}}std::cout << "Time Interval: " << interval_ms << " milliseconds" << std::endl;std::cout << "Output File: " << filename << std::endl;std::cout << "Run Time: " << run_time_seconds << " seconds" << std::endl;ThreadSafeQueue timeQueue;std::atomic<bool> running(true);std::atomic<int> file_index(1); // For log rotation// Producer thread: collects timestamps at specified intervalsstd::thread producer([&timeQueue, &running, interval_ms]() {using clock = std::chrono::steady_clock;auto next_time = clock::now();while (running.load()) {// Get current time and push to queuestd::string currentTime = getCurrentTimeString();timeQueue.push(currentTime);// Calculate next time pointnext_time += std::chrono::milliseconds(interval_ms);// Sleep until the next time pointstd::this_thread::sleep_until(next_time);// Adjust next_time if we're behind scheduleauto now = clock::now();if (now > next_time) {next_time = now;}}});// Consumer thread: writes timestamps to the file, handles log rotation, and detects time jumpsstd::thread consumer([&timeQueue, &running, &filename, &file_index, max_file_size]() {std::ofstream outFile(filename, std::ios::out | std::ios::app);if (!outFile.is_open()) {std::cerr << "Unable to open file for writing: " << filename << std::endl;running.store(false);return;}uint64_t last_timestamp_us = 0; // To store the last timestamp in microsecondswhile (running.load()) {// Wait for 1 second before writing to the filestd::this_thread::sleep_for(std::chrono::seconds(1));// Retrieve all timestamps from the queuestd::queue<std::string> tempQueue = timeQueue.popAll();// Write timestamps to the filewhile (!tempQueue.empty()) {std::string current_timestamp_str = tempQueue.front();tempQueue.pop();uint64_t current_timestamp_us = parseTimestamp(current_timestamp_str);bool time_jump = false;if (last_timestamp_us != 0 && current_timestamp_us < last_timestamp_us) {time_jump = true;}if (time_jump) {outFile << current_timestamp_str << " [TIME_JUMP]" << std::endl;} else {outFile << current_timestamp_str << std::endl;}last_timestamp_us = current_timestamp_us;}outFile.flush(); // Ensure data is written to the file// Check if file size exceeds the maximum limitstd::size_t current_size = getFileSize(filename);if (current_size >= max_file_size) {outFile.close();// Generate a new filename with an indexstd::ostringstream new_filename;new_filename << filename << "." << file_index++;// Rename the current fileif (std::rename(filename.c_str(), new_filename.str().c_str()) != 0) {std::cerr << "Failed to rotate log file." << std::endl;} else {std::cout << "Rotated log file to " << new_filename.str() << std::endl;}// Open a new fileoutFile.open(filename, std::ios::out | std::ios::app);if (!outFile.is_open()) {std::cerr << "Unable to open new file for writing: " << filename << std::endl;running.store(false);return;}// Reset last_timestamp_us after rotationlast_timestamp_us = 0;}}// Write any remaining timestamps before exitingstd::queue<std::string> tempQueue = timeQueue.popAll();while (!tempQueue.empty()) {std::string current_timestamp_str = tempQueue.front();tempQueue.pop();uint64_t current_timestamp_us = parseTimestamp(current_timestamp_str);bool time_jump = false;if (last_timestamp_us != 0 && current_timestamp_us < last_timestamp_us) {time_jump = true;}if (time_jump) {outFile << current_timestamp_str << " [TIME_JUMP]" << std::endl;} else {outFile << current_timestamp_str << std::endl;}last_timestamp_us = current_timestamp_us;}outFile.flush();outFile.close();});std::cout << "Program will run for " << run_time_seconds << " seconds and then exit." << std::endl;// Let the program run for the specified durationstd::this_thread::sleep_for(std::chrono::seconds(run_time_seconds));running.store(false);// Wait for threads to finishproducer.join();consumer.join();std::cout << "Program has ended." << std::endl;return 0;
}

2. 編譯與運行

2.1 編譯

g++ -std=c++11 -pthread -o time_logger time_logger.cpp

運行

• 使用默認設(shè)置（40毫秒間隔，輸出文件為timestamps.txt，運行1小時）：

  ./time_logger
  

• 自定義設(shè)置（例如，100毫秒間隔，輸出文件為output.txt，運行2小時）：

  ./time_logger -i 100 -f output.txt -t 7200
  

2.2 示例日志文件

以下是日志文件timestamps.txt的一部分示例內(nèi)容，其中標記了時間跳變：

2024-04-27 12:34:56.789123
2024-04-27 12:34:56.829456
2024-04-27 12:34:56.869789
2024-04-27 12:34:56.809012 [TIME_JUMP]
2024-04-27 12:34:56.849345
...

3. 附完整代碼

// g++ -std=c++11 -pthread -o time_logger time_logger.cpp
#include <iostream>
#include <fstream>
#include <queue>
#include <deque>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <sys/time.h>
#include <atomic>
#include <string>
#include <cstdlib>
#include <iomanip>
#include <sstream>
#include <sys/stat.h>// Thread-safe queue for storing timestamps
class ThreadSafeQueue {
public:// Push a new timestamp into the queuevoid push(const std::string& value) {std::lock_guard<std::mutex> lock(mtx_);queue_.push(value);cv_.notify_one();}// Retrieve and clear all timestamps from the queuestd::queue<std::string> popAll() {std::lock_guard<std::mutex> lock(mtx_);std::queue<std::string> temp;std::swap(temp, queue_);return temp;}private:std::queue<std::string> queue_;std::mutex mtx_;std::condition_variable cv_;
};// Function to get the current time as a formatted string
std::string getCurrentTimeString() {struct timeval tv;gettimeofday(&tv, nullptr);struct tm* tm_info = localtime(&tv.tv_sec);char buffer[64];strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", tm_info);// Append microsecondschar currentTime[100];snprintf(currentTime, sizeof(currentTime), "%s.%06ld", buffer, tv.tv_usec);return std::string(currentTime);
}// Function to get the size of a file in bytes
std::size_t getFileSize(const std::string& filename) {struct stat stat_buf;int rc = stat(filename.c_str(), &stat_buf);return rc == 0 ? stat_buf.st_size : 0;
}// Function to parse timestamp string to microseconds since epoch
uint64_t parseTimestamp(const std::string& timestamp_str) {struct tm tm_info;int microseconds = 0;// Split the timestamp into datetime and microsecondssize_t dot_pos = timestamp_str.find('.');if (dot_pos == std::string::npos) {// If no microseconds part, parse as isif (strptime(timestamp_str.c_str(), "%Y-%m-%d %H:%M:%S", &tm_info) == nullptr) {return 0;}} else {std::string datetime_str = timestamp_str.substr(0, dot_pos);std::string micro_str = timestamp_str.substr(dot_pos + 1);// Parse datetime partif (strptime(datetime_str.c_str(), "%Y-%m-%d %H:%M:%S", &tm_info) == nullptr) {return 0;}// Parse microseconds parttry {microseconds = std::stoi(micro_str);} catch (...) {microseconds = 0;}}time_t seconds = mktime(&tm_info);if (seconds == -1) {return 0;}uint64_t total_microseconds = static_cast<uint64_t>(seconds) * 1000000 + microseconds;return total_microseconds;
}int main(int argc, char* argv[]) {// Default valuesint interval_ms = 40; // Default interval of 40 millisecondsstd::string filename = "timestamps.txt"; // Default filenameint run_time_seconds = 3600; // Default run time of 1 hour (3600 seconds)const std::size_t max_file_size = 100 * 1024 * 1024; // 100MBbool selective_logging = true; // Default: enable selective logging// Parse command-line argumentsfor(int i = 1; i < argc; ++i) {std::string arg = argv[i];if((arg == "-i" || arg == "--interval") && i + 1 < argc) {interval_ms = std::atoi(argv[++i]);if(interval_ms <= 0) {std::cerr << "Invalid interval. Using default value of 40 milliseconds." << std::endl;interval_ms = 40;}}else if((arg == "-f" || arg == "--file") && i + 1 < argc) {filename = argv[++i];}else if((arg == "-t" || arg == "--time") && i + 1 < argc) {run_time_seconds = std::atoi(argv[++i]);if(run_time_seconds <= 0) {std::cerr << "Invalid run time. Using default value of 3600 seconds (1 hour)." << std::endl;run_time_seconds = 3600;}}else if(arg == "--disable_selective_logging") {selective_logging = false;}else if(arg == "-h" || arg == "--help") {std::cout << "Usage: " << argv[0] << " [options]\n"<< "Options:\n"<< "  -i, --interval <milliseconds>        Set the time interval, default is 40 milliseconds\n"<< "  -f, --file <filename>                Set the output filename, default is timestamps.txt\n"<< "  -t, --time <seconds>                 Set the run time in seconds, default is 3600 seconds (1 hour)\n"<< "      --disable_selective_logging       Disable selective logging feature\n"<< "  -h, --help                           Show this help message\n";return 0;}else {std::cerr << "Unknown argument: " << arg << "\nUse -h or --help to see available options." << std::endl;return 1;}}std::cout << "Time Interval: " << interval_ms << " milliseconds" << std::endl;std::cout << "Output File: " << filename << std::endl;std::cout << "Run Time: " << run_time_seconds << " seconds" << std::endl;std::cout << "Selective Logging: " << (selective_logging ? "Enabled" : "Disabled") << std::endl;ThreadSafeQueue timeQueue;std::atomic<bool> running(true);std::atomic<int> file_index(1); // For log rotation// Producer thread: collects timestamps at specified intervalsstd::thread producer([&timeQueue, &running, interval_ms]() {using clock = std::chrono::steady_clock;auto next_time = clock::now();while (running.load()) {// Get current time and push to queuestd::string currentTime = getCurrentTimeString();timeQueue.push(currentTime);// Calculate next time pointnext_time += std::chrono::milliseconds(interval_ms);// Sleep until the next time pointstd::this_thread::sleep_until(next_time);// Adjust next_time if we're behind scheduleauto now = clock::now();if (now > next_time) {next_time = now;}}});// Consumer thread: writes timestamps to the file, handles log rotation, and detects time jumpsstd::thread consumer([&timeQueue, &running, &filename, &file_index, max_file_size, selective_logging]() {std::ofstream outFile(filename, std::ios::out | std::ios::app);if (!outFile.is_open()) {std::cerr << "Unable to open file for writing: " << filename << std::endl;running.store(false);return;}uint64_t last_timestamp_us = 0; // To store the last timestamp in microsecondsstd::deque<std::string> recent_timestamps; // To store recent timestamps for bufferconst size_t buffer_size = 10; // Number of timestamps to keep before a time jumpsize_t normal_count = 0; // Counter for normal timestampsconst size_t normal_threshold = 20; // Write every 20 normal timestampsbool in_jump_mode = false; // Flag indicating if currently in jump modesize_t jump_remaining = 0; // Number of jump-related timestamps remaining to writestd::vector<std::string> jump_buffer; // Buffer to store jump-related timestampswhile (running.load()) {// Wait for 1 second before processingstd::this_thread::sleep_for(std::chrono::seconds(1));// Retrieve all timestamps from the queuestd::queue<std::string> tempQueue = timeQueue.popAll();while (!tempQueue.empty()) {std::string current_timestamp_str = tempQueue.front();tempQueue.pop();// Update recent_timestamps bufferrecent_timestamps.push_back(current_timestamp_str);if (recent_timestamps.size() > buffer_size) {recent_timestamps.pop_front();}uint64_t current_timestamp_us = parseTimestamp(current_timestamp_str);bool time_jump = false;if (selective_logging && last_timestamp_us != 0 && current_timestamp_us < last_timestamp_us) {time_jump = true;}if (selective_logging && time_jump && !in_jump_mode) {// Time jump detected, enter jump modein_jump_mode = true;jump_remaining = 10; // Number of timestamps to write after the jumpjump_buffer.clear();// Add the last 10 timestamps before the jumpfor (const auto& ts : recent_timestamps) {jump_buffer.push_back(ts);}// Add the current (jump) timestampjump_buffer.push_back(current_timestamp_str);last_timestamp_us = current_timestamp_us;}else if (selective_logging && in_jump_mode) {// In jump mode, collect the next 10 timestampsjump_buffer.push_back(current_timestamp_str);jump_remaining--;last_timestamp_us = current_timestamp_us;if (jump_remaining == 0) {// Write all collected jump timestamps to file with [TIME_JUMP] flagfor (size_t i = 0; i < jump_buffer.size(); ++i) {if (i == buffer_size) { // The jump timestampoutFile << jump_buffer[i] << " [TIME_JUMP]" << std::endl;}else {outFile << jump_buffer[i] << std::endl;}}outFile.flush();jump_buffer.clear();in_jump_mode = false;}}else {// Normal timestamp processingnormal_count++;if (normal_count >= normal_threshold) {outFile << current_timestamp_str << std::endl;outFile.flush();normal_count = 0;}last_timestamp_us = current_timestamp_us;}// Check if file size exceeds the maximum limitstd::size_t current_size = getFileSize(filename);if (current_size >= max_file_size) {outFile.close();// Generate a new filename with an indexstd::ostringstream new_filename;new_filename << filename << "." << file_index++;// Rename the current fileif (std::rename(filename.c_str(), new_filename.str().c_str()) != 0) {std::cerr << "Failed to rotate log file." << std::endl;} else {std::cout << "Rotated log file to " << new_filename.str() << std::endl;}// Open a new fileoutFile.open(filename, std::ios::out | std::ios::app);if (!outFile.is_open()) {std::cerr << "Unable to open new file for writing: " << filename << std::endl;running.store(false);return;}// Reset last_timestamp_us and buffers after rotationlast_timestamp_us = 0;recent_timestamps.clear();jump_buffer.clear();in_jump_mode = false;normal_count = 0;}}}// Handle any remaining timestamps before exitingstd::queue<std::string> remainingQueue = timeQueue.popAll();while (!remainingQueue.empty()) {std::string current_timestamp_str = remainingQueue.front();remainingQueue.pop();// Update recent_timestamps bufferrecent_timestamps.push_back(current_timestamp_str);if (recent_timestamps.size() > buffer_size) {recent_timestamps.pop_front();}uint64_t current_timestamp_us = parseTimestamp(current_timestamp_str);bool time_jump = false;if (selective_logging && last_timestamp_us != 0 && current_timestamp_us < last_timestamp_us) {time_jump = true;}if (selective_logging && time_jump && !in_jump_mode) {// Time jump detected, enter jump modein_jump_mode = true;jump_remaining = 10; // Number of timestamps to write after the jumpjump_buffer.clear();// Add the last 10 timestamps before the jumpfor (const auto& ts : recent_timestamps) {jump_buffer.push_back(ts);}// Add the current (jump) timestampjump_buffer.push_back(current_timestamp_str);last_timestamp_us = current_timestamp_us;}else if (selective_logging && in_jump_mode) {// In jump mode, collect the next 10 timestampsjump_buffer.push_back(current_timestamp_str);jump_remaining--;last_timestamp_us = current_timestamp_us;if (jump_remaining == 0) {// Write all collected jump timestamps to file with [TIME_JUMP] flagfor (size_t i = 0; i < jump_buffer.size(); ++i) {if (i == buffer_size) { // The jump timestampoutFile << jump_buffer[i] << " [TIME_JUMP]" << std::endl;}else {outFile << jump_buffer[i] << std::endl;}}outFile.flush();jump_buffer.clear();in_jump_mode = false;}}else {// Normal timestamp processingnormal_count++;if (normal_count >= normal_threshold) {outFile << current_timestamp_str << std::endl;outFile.flush();normal_count = 0;}last_timestamp_us = current_timestamp_us;}// Check if file size exceeds the maximum limitstd::size_t current_size = getFileSize(filename);if (current_size >= max_file_size) {outFile.close();// Generate a new filename with an indexstd::ostringstream new_filename;new_filename << filename << "." << file_index++;// Rename the current fileif (std::rename(filename.c_str(), new_filename.str().c_str()) != 0) {std::cerr << "Failed to rotate log file." << std::endl;} else {std::cout << "Rotated log file to " << new_filename.str() << std::endl;}// Open a new fileoutFile.open(filename, std::ios::out | std::ios::app);if (!outFile.is_open()) {std::cerr << "Unable to open new file for writing: " << filename << std::endl;running.store(false);return;}// Reset last_timestamp_us and buffers after rotationlast_timestamp_us = 0;recent_timestamps.clear();jump_buffer.clear();in_jump_mode = false;normal_count = 0;}}outFile.flush();outFile.close();});std::cout << "Program will run for " << run_time_seconds << " seconds and then exit." << std::endl;// Let the program run for the specified durationstd::this_thread::sleep_for(std::chrono::seconds(run_time_seconds));running.store(false);// Wait for threads to finishproducer.join();consumer.join();std::cout << "Program has ended." << std::endl;return 0;
}