CODEWITHSUNDEEP
c++multithreading
Lemon Drop
Lemon Drop

Reputation: 2133

C++ Thread access issue with class member variables

After using threads for a while, I got into a situation where I needed a thread to run forever until a a function (or any sort of event) was called. To do this I created a bool value to control a while loop inside the function that was executed by the thread, but I quickly noticed that external variables are not updated after a thread starts running, causing the thread to never stop when it was asked to.

Heres some simple code to represent the issue:

#include <cstdio>
#include <thread>
#include <chrono>

class A {
public:
    A();

    void startThread();
    void endThread();
private:
    void threadCall();
    bool active;
};

int main() {
    A threadThing;
    threadThing.startThread();
    printf("[M] Thread Created\n");
    std::this_thread::sleep_for(std::chrono::seconds(5));
    threadThing.endThread();
    printf("[M] Thread Killed\n");
    std::this_thread::sleep_for(std::chrono::seconds(5));

    return 0;
}

A::A() {
    active = false;
}

void A::startThread() {
    active = true;
    std::thread AThread(&A::threadCall, *this);
    AThread.detach();
}

void A::endThread() {
    active = false;
}

void A::threadCall() {
    printf("[T] Thread Started\n");
    while (active) {
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }
    printf("[T] Thread Ended\n");
}

The expected result of this would be that the main function starts the thread, the thread says it started, then 4 seconds later the thread is killed and the thread says it ended, when in reality the thread never says it ends. Is there a way to let the thread access the 'active' variable, or is my approach to this problem incorrect altogether? (Side note, I did try to figure this out on my own but only got stuff like local thread storage which seems like its only for storage inside of threads, not access to the outside but I could be wrong)

Upvotes: 8

Views: 17878

Answers (2)

Jesse Laning
Jesse Laning

Reputation: 490

What you need to do is pass an A class pointer as an argument to your function that is your thread.

void A::startThread()
{
    active = true;
    std::thread AThread(threadCall, this);
    AThread.detach();
}
void A::threadCall(A *aClass)
{
    printf("[T] Thread Started\n");
    while (aClass->active)
    {
        std::this_thread::sleep_for(std::chrono::seconds(2));
    }
    printf("[T] Thread Ended\n");
}

Upvotes: 6

yngccc
yngccc

Reputation: 5694

The problem is with the constructor of std::thread, it copies/moves by default.

std::thread AThread(&A::threadCall, *this);

this copies the object into the new thread, so checking the active variable in the new object has no effect.

you can remove the *

std::thread AThread(&A::threadCall, this);

you pass the object pointer into the new thread, it will call like the method like this(*this).threadCall().

Edit: as the comments say, this is not guarantee to be thread safe, you need to use std::atomic<bool> to be safe.

Upvotes: 10

Related Questions