Executing a non blocking thread in C++

Question

I have a main program, this main program executes a thread that perform an action until the user triggers a stop. The problem that I have is if I add th.join() the main program won't continue until the thread finishes. And If there is no .join() the program crashs.

#include <iostream>
#include <thread>
#include <optional>

static bool s_finished = false;

using namespace std::literals::chrono_literals;

void SendData(int id)
{
    std::cout << "Working thread: " << id << std::endl;
    std::cout << "Started thread id: " << std::this_thread::get_id() << std::endl;

    while (!s_finished)
    {
        std::cout << "Working\n";
        std::this_thread::sleep_for(1s);
    }

}

void startRecording(std::optional<int> t)
{

      std::thread th1 (SendData, 1);
     //th1.join();


    std::cout << "[startRecording] Other Task" << std::endl;
}

void stopRecording()
{
    s_finished = true;
    std::cout << "[stopRecording] Other Task" << std::endl;
}

int main()
{
    std::cout << "Start Program!" << std::endl;

    startRecording();

    std::this_thread::sleep_for(5s);

    stopRecording();

    return 0;
}

How can I do this?

Answer 1

Joining a thread will cause the program to stop until that thread is finished, and that's why the program blocks. We have to call join() eventually so that all child threads finish before the program exits, but we shouldn't call join until we need the child thread to be finished.

The simplest way to get the program to work is to return the thread from startRecording, so that we have control of it inside main. Then, we join the thread at the end of main, after we call stopRecording.

#include <iostream>
#include <thread>
#include <optional>
#include <atomic>

// (1) This needs to be atomic to avoid data races
std::atomic<bool> s_finished { false };

using namespace std::literals::chrono_literals;

void SendData(int id)
{
    std::cout << "Working thread: " << id << std::endl;
    std::cout << "Started thread id: " << std::this_thread::get_id() << std::endl;

    while (!s_finished)
    {
        std::cout << "Working\n";
        std::this_thread::sleep_for(1s);
    }

}

std::thread startRecording(std::optional<int> t)
{
    std::thread th1 (SendData, 1);

    std::cout << "[startRecording] Other Task" << std::endl;

    // (2) We return the thread so we can join it in main:
    return th1;
}

void stopRecording()
{
    s_finished = true;
    std::cout << "[stopRecording] Other Task" << std::endl;
}

int main()
{
    std::cout << "Start Program!" << std::endl;

    // (3) We save the thread to a variable named 'worker' 
    // so we can join it later. I also added an input to startRecording b/c it needed one
    std::thread worker = startRecording(std::optional<int>{1});

    std::this_thread::sleep_for(5s);

    stopRecording();

    // (4) Join here, at the end
    worker.join(); 

    return 0;
}

Now, the program prints the expected output, then exits without problems:

Start Program!
[startRecording] Other Task
Working thread: 1
Started thread id: 139985258444544
Working
Working
Working
Working
Working
[stopRecording] Other Task

I marked my changes with (1), (2), (3), and (4) in the comments of the code. They're pretty small, and if you have questions about any of them I can provide additional explanation!

Addendum - using global variables when the signature of startRecording can't be changed

In general, it's best to avoid global variables, but I know it's not always possible to do so. if startRecording's signature can't be changed, we can't return a thread, so the thread has to be accessed globally. Here's how to do that:

#include <iostream>
#include <thread>
#include <optional>
#include <atomic>

// (1) This needs to be atomic to avoid data races
std::atomic<bool> s_finished { false };

// (2) we initialize this in startRecording
std::thread worker;

using namespace std::literals::chrono_literals;

void SendData(int id)
{
    std::cout << "Working thread: " << id << std::endl;
    std::cout << "Started thread id: " << std::this_thread::get_id() << std::endl;

    while (!s_finished)
    {
        std::cout << "Working\n";
        std::this_thread::sleep_for(1s);
    }

}

void startRecording(std::optional<int> t)
{
    // (3) worker gets initialized, and thread starts
    worker = std::thread(SendData, 1);

    std::cout << "[startRecording] Other Task" << std::endl;
}

void stopRecording()
{
    s_finished = true;
    std::cout << "[stopRecording] Other Task" << std::endl;
}

int main()
{
    std::cout << "Start Program!" << std::endl;

    startRecording(std::optional<int>{1});

    std::this_thread::sleep_for(5s);

    stopRecording();

    // (4) Join here, at the end
    worker.join(); 

    return 0;
}