Синхронизация потоков с time_point

void f(set<pair<chrono::system_clock::time_point, int64_t> >& TP, map<Store*, vector<shared_ptr<Store::Child > > >&Children) {
    set<pair<chrono::system_clock::time_point, int64_t> > ::iterator it;
    for (it = TP.begin(); it != TP.end(); it++) {
        {unique_lock<mutex>UL1(MU);
 
        Tp_Next = it->first;
        Tp_Try = it->first - chrono::seconds(5);
        }
         
         time_t  ON= std::chrono::system_clock::to_time_t(it->first);
         tm on;
         localtime_s(&on, &ON);
         int year1 = on.tm_year+1900, month=on.tm_mon+1, day=on.tm_mday;
         string S = "";
         ostringstream sstr;
         sstr << year1<<month<<day;
         S=sstr.str();
         
         map<Store*, vector<shared_ptr<Store::Child > > >::iterator it1;
        
         Check = false;
         this_thread::sleep_until(it->first);
         unique_lock<mutex>UL1(MU);
        
         cout << endl << "TIME :" << endl;
         for (it1 = Children.begin(); it1 != Children.end(); it1++) {
 
             if (it1->first->Name == S) {
 
                 it1->first->Get(it1->first->mp, it->second);
                
 
             }
 
             break;
 
         }
         Check = true; 
         CV.notify_one();
    }
    
}
 
void User_Request(map< Store*, vector<shared_ptr<Store::Child > > >& Children) {
   
    string Answer1, Answer, Object, Main_Object = "";
    bool Bl = true;
    
    
    while ((chrono::system_clock::now()) <= Tp_End) {
        
        
        if ((chrono::system_clock::now()) > Tp_Try) {
            this_thread::sleep_until(Tp_Next);
            unique_lock<mutex>UL1(MU);
            CV.wait(UL1, is_printed);
            
        }
       
            {unique_lock<mutex>UL1(MU);
            cout << "Do you need to work with the main objects' store or with its' substore?";
            }
        
        
        cin >> Answer1;
 
        if ((chrono::system_clock::now()) > Tp_Try) {
            this_thread::sleep_until(Tp_Next);
            unique_lock<mutex>UL1(MU);
            CV.wait(UL1, is_printed);
 
        }
 
        {unique_lock<mutex>UL1(MU);
        cout << "Enter the name";
        }
        
        cin >> Object;
 
   
        if ((chrono::system_clock::now()) > Tp_Try) {
            this_thread::sleep_until(Tp_Next);
            unique_lock<mutex>UL1(MU);
            CV.wait(UL1, is_printed);
 
        }
 
        {unique_lock<mutex>UL1(MU);
        cout << "What do you need to do ? Enter get, update, show, query, range_query, remove";
        }
        
        cin >> Answer;// до этого участка все работает
   
        (Answer1.find("main") != -1) ? Bl = true : Bl = !Bl;
        shared_ptr<Store >Obj;
        shared_ptr<Store::Child> Obj1;
      
        
        Store* x =nullptr; 
        map<Store*, vector<shared_ptr<Store::Child > > >::iterator it;
        if (Bl == true) {
 
            for (it = Children.begin(); it != Children.end(); it++) {
 
                if (it->first->Name == Object) {
 
                    Obj.reset(x);
                    
                    break;
                }
            }
        }
        else {
            
            for (it = Children.begin(); it != Children.end(); it++) {
                for (auto it2 : it->second) {
                    if (it2->Name == Object) {
                        Obj1 = it2;
                        
                        break;
                    }
                }
            }
        }
  
       
       
        string key, value;
        double a, b;
        int64_t ID = 0;
        
        if (Answer == "get") {
         
            if ((chrono::system_clock::now()) > Tp_Try) {
                this_thread::sleep_until(Tp_Next);
                unique_lock<mutex>UL1(MU);
                CV.wait(UL1, is_printed);
 
            }
 
            {unique_lock<mutex>UL1(MU);
            cout << "Enter the ID";
            }
            
            cin >> ID;
 
            if ((chrono::system_clock::now())> Tp_Try) {
                this_thread::sleep_until(Tp_Next);
                unique_lock<mutex>UL1(MU);
                CV.wait(UL1, is_printed);
 
            }
 
            {unique_lock<mutex>UL1(MU);
            (Bl == true) ? Obj->Get(Obj->mp, ID) : Obj1->Get(ID);
            }
                 
        }
 
        else if (Answer == "update") {
            if ((chrono::system_clock::now()) > Tp_Try) {
                this_thread::sleep_until(Tp_Next);
            }
 
            {unique_lock<mutex>UL1(MU);
            cout << "Enter the ID, key, value";
            }
            
            cin >> ID >> key >> value;
 
            if ((chrono::system_clock::now()) > Tp_Try) {
                this_thread::sleep_until(Tp_Next);
            }
 
            {unique_lock<mutex>UL1(MU);
            (Bl == true) ? Obj->Update(ID, key, value) : Obj1->Update(ID, key, value);
            }
            
        }
 
        else if (Answer == "show") {
            if ((chrono::system_clock::now()) > Tp_Try) {
                this_thread::sleep_until(Tp_Next);
                unique_lock<mutex>UL1(MU);
                CV.wait(UL1, is_printed);
 
            }
 
            {unique_lock<mutex>UL1(MU);
            (Bl == true) ? Obj->Show(Obj->mp) : Obj1->Show();
            }
            
        }