#include <functional>
#include <iostream>
#include <chrono>
#include <thread>
#include <atomic>
#include <mutex>
 
std::mutex mutex;
std::atomic<bool> stop = {false};
unsigned last_result = 0; // Whatever thread_1ms produces.
 
void thread_1ms_action() {
    // Do the work.
 
    // Update the last result.
    {
        std::unique_lock<std::mutex> lock(mutex);
        ++last_result;
    }
}
 
void thread_1333us_action() {
    // Copy thread_1ms result.
    unsigned last_result_copy;
    {
        std::unique_lock<std::mutex> lock(mutex);
        last_result_copy = last_result;
    }
 
    // Do the work.
    std::cout << last_result_copy << '\n';
}
 
void periodic_action_thread(std::chrono::microseconds period, std::function<void()> const& action) {
    auto const start = std::chrono::steady_clock::now();
    while(!stop.load(std::memory_order_relaxed)) {
        // Do the work.
        action();
 
        // Wait till the next period start.
        auto now = std::chrono::steady_clock::now();
        auto iterations = (now - start) / period;
        auto next_start = start + (iterations + 1) * period;
        std::this_thread::sleep_until(next_start);
    }
}
 
int main() {
    std::thread a(periodic_action_thread, std::chrono::milliseconds(1), thread_1ms_action);
    std::thread b(periodic_action_thread, std::chrono::microseconds(13333), thread_1333us_action);
 
    std::this_thread::sleep_for(std::chrono::seconds(1));
    stop = true;
    a.join();
    b.join();
}
 

I2luY2x1ZGUgPGZ1bmN0aW9uYWw+CiNpbmNsdWRlIDxpb3N0cmVhbT4KI2luY2x1ZGUgPGNocm9ubz4KI2luY2x1ZGUgPHRocmVhZD4KI2luY2x1ZGUgPGF0b21pYz4KI2luY2x1ZGUgPG11dGV4PgoKc3RkOjptdXRleCBtdXRleDsKc3RkOjphdG9taWM8Ym9vbD4gc3RvcCA9IHtmYWxzZX07CnVuc2lnbmVkIGxhc3RfcmVzdWx0ID0gMDsgLy8gV2hhdGV2ZXIgdGhyZWFkXzFtcyBwcm9kdWNlcy4KCnZvaWQgdGhyZWFkXzFtc19hY3Rpb24oKSB7CiAgICAvLyBEbyB0aGUgd29yay4KCiAgICAvLyBVcGRhdGUgdGhlIGxhc3QgcmVzdWx0LgogICAgewogICAgICAgIHN0ZDo6dW5pcXVlX2xvY2s8c3RkOjptdXRleD4gbG9jayhtdXRleCk7CiAgICAgICAgKytsYXN0X3Jlc3VsdDsKICAgIH0KfQoKdm9pZCB0aHJlYWRfMTMzM3VzX2FjdGlvbigpIHsKICAgIC8vIENvcHkgdGhyZWFkXzFtcyByZXN1bHQuCiAgICB1bnNpZ25lZCBsYXN0X3Jlc3VsdF9jb3B5OwogICAgewogICAgICAgIHN0ZDo6dW5pcXVlX2xvY2s8c3RkOjptdXRleD4gbG9jayhtdXRleCk7CiAgICAgICAgbGFzdF9yZXN1bHRfY29weSA9IGxhc3RfcmVzdWx0OwogICAgfQoKICAgIC8vIERvIHRoZSB3b3JrLgogICAgc3RkOjpjb3V0IDw8IGxhc3RfcmVzdWx0X2NvcHkgPDwgJ1xuJzsKfQoKdm9pZCBwZXJpb2RpY19hY3Rpb25fdGhyZWFkKHN0ZDo6Y2hyb25vOjptaWNyb3NlY29uZHMgcGVyaW9kLCBzdGQ6OmZ1bmN0aW9uPHZvaWQoKT4gY29uc3QmIGFjdGlvbikgewogICAgYXV0byBjb25zdCBzdGFydCA9IHN0ZDo6Y2hyb25vOjpzdGVhZHlfY2xvY2s6Om5vdygpOwogICAgd2hpbGUoIXN0b3AubG9hZChzdGQ6Om1lbW9yeV9vcmRlcl9yZWxheGVkKSkgewogICAgICAgIC8vIERvIHRoZSB3b3JrLgogICAgICAgIGFjdGlvbigpOwoKICAgICAgICAvLyBXYWl0IHRpbGwgdGhlIG5leHQgcGVyaW9kIHN0YXJ0LgogICAgICAgIGF1dG8gbm93ID0gc3RkOjpjaHJvbm86OnN0ZWFkeV9jbG9jazo6bm93KCk7CiAgICAgICAgYXV0byBpdGVyYXRpb25zID0gKG5vdyAtIHN0YXJ0KSAvIHBlcmlvZDsKICAgICAgICBhdXRvIG5leHRfc3RhcnQgPSBzdGFydCArIChpdGVyYXRpb25zICsgMSkgKiBwZXJpb2Q7CiAgICAgICAgc3RkOjp0aGlzX3RocmVhZDo6c2xlZXBfdW50aWwobmV4dF9zdGFydCk7CiAgICB9Cn0KCmludCBtYWluKCkgewogICAgc3RkOjp0aHJlYWQgYShwZXJpb2RpY19hY3Rpb25fdGhyZWFkLCBzdGQ6OmNocm9ubzo6bWlsbGlzZWNvbmRzKDEpLCB0aHJlYWRfMW1zX2FjdGlvbik7CiAgICBzdGQ6OnRocmVhZCBiKHBlcmlvZGljX2FjdGlvbl90aHJlYWQsIHN0ZDo6Y2hyb25vOjptaWNyb3NlY29uZHMoMTMzMzMpLCB0aHJlYWRfMTMzM3VzX2FjdGlvbik7CgogICAgc3RkOjp0aGlzX3RocmVhZDo6c2xlZXBfZm9yKHN0ZDo6Y2hyb25vOjpzZWNvbmRzKDEpKTsKICAgIHN0b3AgPSB0cnVlOwogICAgYS5qb2luKCk7CiAgICBiLmpvaW4oKTsKfQo=