C++ C++；在指定的时间间隔内调用方法而不进行睡眠

我需要以指定的间隔（1毫秒）执行多个方法。有没有办法在循环中调用方法而不使用sleep，因为我一秒钟内不会在日志文件中获得1000个条目 目前，我已经实现了使用睡眠。数据收集也可能花费很少的时间

#include <iostream>
#include <string>
#include <unordered_map>
#include <functional>
#include <csignal>
#include <chrono>
#include <thread>
#include <fstream>
#include <ctime>
#include <iomanip>
#include <sstream>
#include <windows.h>
#include <atomic>

volatile std::sig_atomic_t gStatus{};

void signalHandler(int sig) {
    gStatus = sig;
}

void feature1(std::string &output) { output = "feature1"; }
void feature2(std::string &output) { output = "feature2"; }
void feature3(std::string &output) { output = "feature3"; }
void feature4(std::string &output) { output = "feature4"; }
void feature5(std::string &output) { output = "feature5"; }
void feature6(std::string &output) { output = "feature6"; }

void processInfoRequest(std::string logFile, std::unordered_map<std::string, std::function<void(std::string &value)>> methodMap)
{
    std::ofstream ofs(logFile);

    std::uint64_t prevTime = 0, curTime = 0, diffTime = 0, tmpTime = 0, scheduleTime = 0, pollPeriod = 1;

    prevTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
    while (gStatus != SIGINT)
    {
        prevTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
        prevTime = prevTime - scheduleTime;

        **//get value**
        auto timenow = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
        ofs << ctime(&timenow);

        for(auto it : methodMap)
        {
            std::string output;
            it.second(output);
            ofs << output << ",";
        }

        ofs << "\n";        

        curTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
        diffTime = curTime - prevTime;

        if (diffTime < pollPeriod)
        {
            diffTime = pollPeriod - diffTime;
            curTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
            std::uint64_t i = 0;
            std::uint64_t n = diffTime / 10;
            std::uint64_t remainingMs = diffTime % 10;
            for (i = 0; i < n; i++)
            {
                std::this_thread::sleep_for(std::chrono::milliseconds(10));
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(remainingMs));

            tmpTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
            scheduleTime = tmpTime - (curTime + diffTime);
        }
        else
        {
            scheduleTime = 0;
        }

    }

    ofs.close();
}


int main()
{
    std::signal(SIGINT, signalHandler);
    std::string output;
    std::unordered_map<std::string, std::function<void(std::string &value)>> methodMap = {
        {"f1", feature1},
        {"f2", feature2},
        {"f3", feature3},
        {"f4", feature4},
        {"f5", feature5},
        {"f6", feature6}
    };
    
    std::thread th1 = std::thread(processInfoRequest, "threadlog.csv", methodMap);

    if (th1.joinable())
        th1.join();
        
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
挥发性std:：sig_原子状态{}；
无效信号处理器（int sig）{
gStatus=sig；
}
void feature1（std:：string&output）{output=“feature1”；}
void feature2（std:：string&output）{output=“feature2”；}
void feature3（std:：string&output）{output=“feature3”；}
void feature4（std:：string&output）{output=“feature4”；}
void feature5（std:：string&output）{output=“feature5”；}
void feature6（std:：string&output）{output=“feature6”；}
void processInfoRequest（std:：string日志文件，std:：无序映射methodMap）
{
std：：ofs流（日志文件）；
std:：uint64_t prevTime=0，curTime=0，diffTime=0，tmpTime=0，scheduleTime=0，pollPeriod=1；
prevTime=std:：chrono:：duration_cast（std:：chrono:：system_clock:：now（）.time_since_epoch（））.count（）；
while（gStatus！=SIGINT）
{
prevTime=std:：chrono:：duration_cast（std:：chrono:：system_clock:：now（）.time_since_epoch（））.count（）；
prevTime=prevTime-scheduleTime；
**//获得价值**
auto timenow=std:：chrono:：system_clock:：to_time_t（std:：chrono:：system_clock:：now（））；
ofs为什么你认为使用睡眠是一个问题？@我认为睡眠时间不准确、不可靠。这是由于许多原因造成的，例如系统时钟分辨率有限和上下文切换可能会强制使你进入睡眠状态，特别是在系统忙时。我还观察到我没有获得预期的ent数量riesWell，你们应该检查delta时间，直到你们每次醒来的下一个动作。你们应该只检查delta，因为上次事件结束。这个问题似乎是相关的：