Correct usage of std::condition_variable to trigger timed execution

I am trying to execute a piece of code in fixed time intervals. I have something based on naked pthread and now I want to do the same using std::thread.

#include <thread>
#include <mutex>
#include <condition_variable>
#include <iostream>

bool running;
std::mutex mutex;
std::condition_variable cond;

void timer(){
  while(running) {
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    std::lock_guard<std::mutex> guard(mutex);
    cond.notify_one();
  }
  cond.notify_one();
}

void worker(){
  while(running){
    std::unique_lock<std::mutex> mlock(mutex);
    cond.wait(mlock);
    std::cout << "Hello World" << std::endl;
    //... do something that takes a variable amount of time ...//
  }
}

int main(){
  running = true;
  auto t_work = std::thread(worker);
  auto t_time = std::thread(timer);
  std::this_thread::sleep_for(std::chrono::milliseconds(10000));

  running = false;
  t_time.join();
  t_work.join();
}

The worker in reality does something that takes a variable amount of time, but it should be scheduled at fixed intervals. It seems to work, but I am pretty new to this, so some things arent clear to me...

• Why do I need a mutex at all? I do not really use a condition, but whenever the timer sends a signal, the worker should do its job.

• Does the timer really need to call cond.notify_one() again after the loop? This was taken from the older code and iirc the reasoning is to prevent the worker to wait forever, in case the timer finishes while the worker is still waiting.

• Do I need the running flag, or is there a nicer way to break out of the loops?

PS: I know that there are other ways to ensure a fixed time interval, and I know that there are some problems with my current approach (eg if worker needs more time than the interval used by the timer). However, I would like to first understand that piece of code, before changing it too much.