Thread: Keeping main() waiting until a function returns

I am reading about concurrency and trying to write a couple of small programs to test.
Objective: launch a function waiter() in the background and another function, intruder(), in the foreground. While waiter() sleeps intruder() does its stuff and if it returns before waiter() awakes, waiter() holds up main() until it 'awakes', then waiter() returns and finally main() returns.
Problem: (a) in main() if I declare waiter() first, as I should, it holds up intruder() as well, (b) if I create a std::thread object with waiter(), detach this thread, run intruder() and then thread.join() it throws std::system_error what(): Invalid argument

Code:

#include <iostream>
#include <chrono>
#include <thread>

void waiter()
{
    using namespace std::chrono_literals;
    std::this_thread::sleep_for(5s);
    std::cout << "Waited 5 secs!\n";
};
void intruder(){std::cout << "Cheeky me ;) \n";};

int main()
{
   waiter();
   // std::thread t(waiter);//throws std::system_error
   // t.detach();
    intruder();
    //t.join();
}

Also can the same objective be met with std::future and std::async? I wrote the following but calling get() on the std::future object returns waiter() immediately before 5 seconds are up and without it intruder() returns and then main() returns before waiter() can:

Code:

#include <iostream>
#include <chrono>
#include <future>

void waiter(){ std::cout << "Waited 5 secs!\n";};
void intruder(){std::cout << "Cheeky me ;) \n";};

int main()
{
   std::future<void> f1= std::async(std::launch::deferred, waiter);
   f1.wait_for(std::chrono::seconds(5));
   intruder();
  // f1.get();//returns waiter() immediately;
}

Many thanks

This works for me:

Code:

// g++ -std=c++14 -Wall -W -o threads threads.cpp -lpthread
#include <iostream>
#include <chrono>
#include <thread>

void waiter() {
    using namespace std::chrono_literals;
    std::this_thread::sleep_for(5s);
    std::cout << "Waited 5 secs!\n";
}

void intruder(){std::cout << "Cheeky me ;) \n";}
 
int main() {
    std::thread t(waiter);
    intruder();
    t.join();
}

Thanks. A follow-up qs please: here sleep_for was part of the waiter() definition but, instead, if within main() I decide to call a function that does not have a pre-defined sleep_for in it's definition and to launch this function in the background with a similar sleep_for condition how might I achieve that? Thanks again

Isn't using std::cout not an atomic operation like this? Shouldn't it be accessed via a lock_guard?

Ah, indeed it is! It looks like it won't result in data races but it will still print incorrectly without programmer synchronization.

King Mir: thank you, I came across

Class thread doesn't have a launch policy. The C++ standard library always tries to start the passed functionality in a new thread. ... Jossutis, Standard Library (2nd ed)

So now I see what you're trying to say.
And for completion, circling back to the second program in my OP, is there a way to achieve the same results with std::future and std::async? Thank you

std::future has a wait and a get method you can use.

std::future.get() would force the waiter() function to start immediately if it was not started yet irrespective of any previous wait_for instructions. So waiter() could return even before the 5s wait is up on the lines of the program in OP. Maybe it can't be done with std::future?

Does this not do what you want?

Code:

#include <iostream>
#include <chrono>
#include <thread>
#include <future>
 
void waiter()
{
    using namespace std::chrono_literals;
    std::this_thread::sleep_for(5s);
    std::cout << "Waited 5 secs!\n";
};


void intruder() { std::cout << "Cheeky me ;) \n"; };
 
int main()
{
    auto const fut = std::async(std::launch::async, waiter);
    intruder();
    fut.wait();
    return 0;
}

Yes, indeed it does. Just wait() w/o the get(). Many thanks