0

Remy posted a great solution to pass any function with any number of arguments to std::thread, here. I was wondering how it could be used for class member functions.

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

#define __PRETTY_FUNCTION__ __FUNCSIG__

std::mutex my_mutex;

template<class Function, class... Args>
void runFunctionInThread(Function f, Args&&... args) {
    // Beside starting a thread, this function performs other 
    // task using the function and its arguments.
    std::thread t(f, std::forward<Args>(args)...);
    t.detach();
}

class MyClass
{
public:
    MyClass() {};

    void myFunc1() { std::unique_lock<std::mutex> lock(my_mutex); std::cout << __PRETTY_FUNCTION__ << "\n"; }
    void myFunc2(int value) { std::unique_lock<std::mutex> lock(my_mutex); std::cout << __PRETTY_FUNCTION__ << "value is " << value << "\n"; }
    void myFunc3(int value1, int value2) { std::unique_lock<std::mutex> lock(my_mutex); std::cout << __PRETTY_FUNCTION__ << "value1+value2 is " << value1 + value2 << "\n"; }

    void manager() {
        void (MyClass::*f1)() = &MyClass::myFunc1;
        void (MyClass::*f2)(int) = &MyClass::myFunc2;
        void (MyClass::*f3)(int,int) = &MyClass::myFunc3;

        runFunctionInThread(f1);
        runFunctionInThread(f2, 2);
        runFunctionInThread(f3, 3, 3);
    }

};

void isolatedFunc1() { std::unique_lock<std::mutex> lock(my_mutex); std::cout << __PRETTY_FUNCTION__ << "\n"; }
void isolatedFunc2(int value) { std::unique_lock<std::mutex> lock(my_mutex); std::cout << __PRETTY_FUNCTION__ << " value is " << value << "\n"; }
void isolatedFunc3(int value1, int value2) { std::unique_lock<std::mutex> lock(my_mutex); std::cout << __PRETTY_FUNCTION__ << " value1+value2 is " << value1 + value2 << "\n"; }

int main()
{
    runFunctionInThread(&isolatedFunc1); // Works flawlessly
    runFunctionInThread(&isolatedFunc2, 2); // Works flawlessly
    runFunctionInThread(&isolatedFunc3, 3, 3); // Works flawlessly

    MyClass m;
    m.manager();

}
afp_2008
  • 1,940
  • 1
  • 19
  • 46
  • 1
    i suppose this is an exercise, but note that creating a thread and immediately calling `join` blocks any concurrency. Your code is quasi sequential – 463035818_is_not_an_ai Dec 17 '20 at 20:10
  • 2
    `std::thread` already handles this for you. It just needs to know which object's member to call. Pass `this` as the first argument after the function pointer. – François Andrieux Dec 17 '20 at 20:12
  • 1
    This looks like a use case for [`std::async`](https://en.cppreference.com/w/cpp/thread/async) rather than `std::thread`. – François Andrieux Dec 17 '20 at 20:14
  • 2
    Which part or Remy's solution isn't working for you? The first argument to `std::thread` is either a function or a member function pointer and `std::thread` does the Right Thing with that. If you want to do something _like_ what `std::thread` does for your own use, you want to have a look at [`std::invoke()`](https://en.cppreference.com/w/cpp/utility/functional/invoke). – Dietmar Kühl Dec 17 '20 at 20:15

1 Answers1

2

If you want to call a member function you'll need to pass the object to std::thread too:

void manager() {
    //...
    runFunctionInThread(f1, this);
    runFunctionInThread(f2, this, 2);
    runFunctionInThread(f3, this, 3, 3);
}

Note: I noticed that you detach your threads. You then need to manually make sure that they have ended before your program does or you are in for surprises at program exit if they are still running.

It's often easier to keep the running threads in a container (like a std::list<std::thread>) and join() them later. In C++20 you could even make it std::list<std::jthread> to have them automatically joined when the container is destroyed.

Ted Lyngmo
  • 93,841
  • 5
  • 60
  • 108