CODEWITHSUNDEEP
c++multithreadingc++11
Brandon
Brandon

Reputation: 510

Creating a class to store threads and calling them

Here is a simplified version of what I am trying to do:

#include <iostream>
#include <vector>
#include <thread>
#include <atomic>

class client {
private:
    std::vector<std::thread> threads;
    std::atomic<bool> running;

    void main() {
        while(running) {
            std::cout << "main" << std::endl;
        }
    }

    void render() {
        while(running) {
            std::cout << "render" << std::endl;
        }
    }
public:
    client() {
        running = true;

        threads.push_back(std::thread(&client::main, this));
        threads.push_back(std::thread(&client::render, this));
    }

    ~client() {
        running = false;
        for(auto& th : threads) th.join();
    };
};

int main() {
    client c;

    std::string inputString;
    getline(std::cin, inputString);

    return 0;
}

(Note: code has been changed since question was written)

What I am trying to do is create a class that holds threads for the main loop(of the class), rendering, and a couple other things. However I cannot get this simplified version to work. I have tried using mutex to lock and unlock the threads, but didn't seem to help any. I do not know why it is not working, but I suspect that it is a result of the use of this in threads.push_back(std::thread(this->main, this));.

The current structure of the code doesn't have to remain... The only requirement is that uses one of it's own member functions as a thread (and that, that thread is stored in the class). I am not sure if this requires two classes or if my attempt to do it in one class was the correct approach. I have seen many examples of creating an object, and then calling a member that creates threads. I am trying to avoid this and instead create the threads within the constructor.

Upvotes: 0

Views: 411

Answers (1)

NathanOliver
NathanOliver

Reputation: 180595

The problem here is that you do not wait for the threads to end. In main you create c. This then spawns the threads. The next thing to happen is to return which destroys c. When c is destroyed it destroys its members. Now when a thread is destroyed if it has not been joined or detached then std::terminate is called and the program ends

What you need to do is in the destructor, set running to false and then call join on both the threads. This will stop the loop in each thread and allow c to be destructed correctly.

Doing this however brings up another issue. running is not an atomic variable so writing to it while threads are reading it is undefined behavior. We can fin that though by changing running to a std::atomic<bool> which provides synchronization.

I also had to make a change to the thread construction. When you want to use a member function the syntax should be

std::thread(&class_name::function_name, pointer_to_instance_of_class_name, function_parameters)

so in this case it would be

threads.push_back(std::thread(&client::main, this));
threads.push_back(std::thread(&client::render, this));

Upvotes: 4

Related Questions