cpp std::this_thread::sleep_for(std::chrono::seconds(sleep_seconds)) for thread execution duration

#include <chrono>
#include <condition_variable>
#include <ctime>
#include <fstream>
#include <future>
#include <iomanip>
#include <iostream>
#include <map>
#include <mutex>
#include <sstream>
#include <thread>
#include <uuid/uuid.h>
#include <vector>

std::string get_time_now()
{
    std::chrono::time_point<std::chrono::high_resolution_clock> now = std::chrono::high_resolution_clock::now();
    time_t raw_time = std::chrono::high_resolution_clock::to_time_t(now);
    struct tm tm_info = *localtime(&raw_time);
    std::stringstream ss;
    std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch());
    std::chrono::milliseconds mills = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
    std::chrono::microseconds micros = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch());
    std::chrono::nanoseconds nanos = std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch());
    ss << std::put_time(&tm_info, "%Y%m%d%H%M%S") 
       << std::setw(3) << std::setfill('0') << std::to_string(mills.count() - seconds.count() * 1000)
       << std::setw(3) << std::setfill('0') << std::to_string(micros.count() - mills.count() * 1000)
       << std::setw(3) << std::setfill('0') << std::to_string(nanos.count() - micros.count() * 1000);
    return ss.str();
} 

char *uuid_value = (char *)malloc(40);
char *get_uuid()
{
    uuid_t new_uuid;
    uuid_generate(new_uuid);
    uuid_unparse(new_uuid, uuid_value);
    return uuid_value;
}
 
bool is_finish=false;
void thread_sleep_for_seconds(const int&sleep_seconds)
{
    std::this_thread::sleep_for(std::chrono::seconds(sleep_seconds));
    is_finish=true;
}

void log_file_sleep_for()
{
    std::fstream w_file("log2.txt",std::ios::app);
    if(!w_file.is_open())
    {
        std::cout<<get_time_now()<<",create or open log2.txt failed!"<<std::endl;
    }

    std::stringstream ss;
    std::uint64_t num=0;
    while(!is_finish)
    {
        ss<<++num<<","<<get_uuid()<<std::endl;
        if(num%1000000==0)
        {
            w_file<<ss.str();
            ss=std::stringstream();
            std::cout<<get_time_now()<<",num:"<<num<<std::endl;
        }
        if(is_finish)
        {
            w_file<<ss.str();
            ss=std::stringstream();
            std::cout<<std::boolalpha<<get_time_now()<<",num:"<<num<<",is_finish:"<<is_finish<<std::endl;
            break;
        }
    }
}

void mt_thread_sleep_for(const int&sleep_seconds)
{
    std::stringstream ss;
    ss<<get_time_now<<",start in "<<__FUNCTION__<<std::endl;
    std::thread t1(thread_sleep_for_seconds,std::cref(sleep_seconds));
    std::thread t2(log_file_sleep_for);
    t1.join();
    t2.join();
    ss<<get_time_now()<<",finish in "<<__FUNCTION__<<std::endl;
    std::cout<<ss.str()<<std::endl;
}

int main(int args, char **argv)
{
    mt_thread_sleep_for(atoi(argv[1]));
}

 

Compile

g++ -g -std=c++2a -I. *.cpp -o h1 -luuid -lpthread

 

Run 

./h1 1000