#include <iostream>
#include <thread>

auto work1(volatile int &run) -> void
{
   const int wait_seconds = 1000;
   int waited = 0;

   while(run != 0)
   {
      while(waited < wait_seconds && run != 0)
      {
         _sleep(500);
         waited += 500;
      }
      if(run != 0)
      {
         std::cout << "do my job1...\n";
         waited = 0;
      }
   }
}

auto work2(volatile int &run) -> void
{
   const int wait_seconds = 1500;
   int waited = 0;

   while(run != 0)
   {
      while(waited < wait_seconds && run != 0)
      {
         _sleep(500);
         waited += 500;
      }
      if(run != 0)
      {
         std::cout << "do my job2...\n";
         waited = 0;
      }
   }
}

auto main(int params_count, char **params) -> int
{
   int run = 1;
   std::cout << "erstelle thread1\n";
   std::thread thread1([&run](void) { work1(run); });
   std::cout << "erstelle thread2\n";
   std::thread thread2([&run](void) { work2(run); });

   std::cout << "sleep 5 seconds\n";
   _sleep(5000);

   std::cout << "programm wird beendet\n";
   run = 0;

   thread1.join();
   thread2.join();

   std::cout << "exit app\n";

   return 0;
}

die beiden threads warten also unterschiedlich lange um ihre arbeit im interval zu erledigen, bzw. gehen raus, wenn run gleich 0 ist.
wie mach ich das mit condition_variable ?

noch ne frage zu meinem beispiel: theoretisch duerfte hier nichts passieren oder ? da es nur einen thread gibt der die variable run aendert.

Meep Meep

Überall wo du auf die "run" Variable zugreifst (lesend oder schreibend) musst du nun die Mutex locken.

Wenn du warten willst bis sich der Inhalt der Variable ändert, dann verwendest du wait der Condition-Variable. Wenn du dabei max. so-und-so lange warten willst, dann nimmst du wait_for . Bzw. wait_until wenn du ne absolute Deadline hast. Wenn du die Variable änderst, dann rufst du notify_all auf.

In deinem Fall ist vermutlich ne absolute Deadline mit der std::steady_clock angesagt.