Thread: multithread: how call a function name from a class, inside of the class?

i did a class for multithread:

Code:

class Multithread
{
private:
    pthread_t threads;
    std::function<void(void)> setf;
    void *multithreadproc(void*)
    {
        //call the function
        setf();
    }
public:

    Multithread(std::function<void(void)> SetFunction)
    {
        setf=SetFunction;
    }

    void call()
    {
        pthread_create(&threads, NULL,std::bind(multithreadproc, this, std::placeholders::_1));//error
    }

    Multithread operator()()
    {
        pthread_create(&threads, NULL,std::bind(multithreadproc, this, std::placeholders::_1), (void*)1);
        return this;
    }

    ~Multithread()
    {
        pthread_exit(NULL);
        setf=nullptr;
    }

};

see(for exemple) the method call:

Code:

pthread_create(&threads, NULL,std::bind(multithreadproc, this, std::placeholders::_1));

i'm trying use the function name on 3rd parameter. but the function is from these class, so i think that i must use bind(). but i get these error:
"no matching function for call to 'bind(<unresolved overloaded function type>, Multithread* const, const std::_Placeholder<1>&)'"
what i'm doing wrong?

I've never used pthreads, but try if std::bind(&Multithread::multithreadproc, this, ...) works.

Originally Posted by Guest

I've never used pthreads, but try if std::bind(&Multithread::multithreadproc, this, ...) works.

don't works.
i did a static functions for recive the pointer:

Code:

class Multithread
{
private:
    pthread_t threads;
    function<void()> multithreadfunction;

public:

    static void *multithreadproc(void *pThisArg)
    {
        Multithread *pThis = static_cast<Multithread*>(pThisArg);
        pThis->multithreadfunction();
        pthread_cancel(pThis->threads);
        pthread_exit(NULL);
        pThis=nullptr;
    }

    Multithread(std::function<void()> SetFunction)
    {
        multithreadfunction=SetFunction;
    }

    void operator ()()
    {
        pthread_create(&threads, 0, &Multithread::multithreadproc, static_cast<void*>(this));

    }
    void cancel()
    {
        pthread_exit(NULL);
        pthread_cancel(threads);
        multithreadfunction=nullptr;
    }

    ~Multithread()
    {
        pthread_cancel(threads);
        pthread_exit(NULL);
        multithreadfunction=nullptr;
    }

};

how i use it:

Code:

void text()
{
    static int i=0;
    do
    {
        i=i+1;
        cout << "hello";
        Sleep(1000);
    }while(i<5);

}
//..............
Multithread mtltest(text);
    mtltest();

the function is called. but, when i close the application, seems that the thread continues activated
the process isn't terminated

finally it's fixed:

Code:

class Multithread
{
private:
    pthread_t threads;
    function<void()> multithreadfunction;

public:

    static void *multithreadproc(void *pThisArg)
    {
        Multithread *pThis = static_cast<Multithread*>(pThisArg);
        pThis->multithreadfunction();
        return nullptr;//terminates the thread
    }

    Multithread(std::function<void()> SetFunction)
    {
        multithreadfunction=SetFunction;
    }

    void operator ()()
    {
        pthread_create(&threads, nullptr, &Multithread::multithreadproc, static_cast<void*>(this));

    }
};

heres a sample:

Code:

void text()
{
    static int i=0;
    do
    {
        i=i+1;
        cout << "hello";
        Sleep(1000);
    }while(i<5);

}

//..........
Multithread mtltest(text);
    mtltest();

like you see i don't need use the pthread_exit(). i just need return the nullptr on my static function.
thanks for all

Originally Posted by Elysia

Or, you know, you can use C++ instead of C:

and use a thread pool instead of launching threads irresponsibely.

thanks to all

1. if we are to limit ourself to what the standard provides us,
the most clever program we could write is a multi-threaed console
application which reads and writes to files.

C++ is the ritchest in terms of language features but one of the poorest
in terms of utilities. the browser we are using at this very moment
is written in C++ and (probably) use a thread pool.

so I don't get this claim. C++ was never "battaries included" language
like Java or C#. we always had to write our own extensions or integrate
other developers libraries - otherwise the best thing we could have write
is basic console applications and nothing more.

"Depends on the task at hand, but regardless, thread pools aren't part of the standard, so they add more complexity instead of removing complexity as going from C to C++ does."
"I also object to your broad assertion that lauching threads is implicitly irresponsible. On what do you base that claim"

it's clear that the OP is just learning C++ and doesn't write production code,
so I don't want to dig further on the subject.
Elisya suggested (or followed the idea) that the OP should overload the ()
operator and this operator will launch anonymus thread that will be detached
on the spot.

well,kill me but this seems pretty irresponsible for me.
just like returning a raw pointer to inner a variable, just like
using raw "new" and "delete" and many more things we *can* do, but we
actually shouldn't in most of the cases.

Design wise , following the design that was proposed is obsurd.
a good code should:
1) work
2) be safe as possible
3) be intuitive as possible
4) be explenatory as possible.

so here:

1) we overload the () operator on an object named "Multithread".
well, this isn't pretty obvious to me what exactly does () mean.
I actually would suspect that the constructor itself construct a
new thread , the () notation is pretty much ambiguous. does it launch
a new thread? wake a sleeping one? launches a new thread and enqueue
it somewhere ? we don't have any intuition on what () means. nor
it's very explenatory.

2) are you guys realize a thread is a *heavy* object with many many
implication on the system itself? thread is not a string. it's implemented
with kernel object and makes heavy system calls. one should not
just create threads as he wishes!
for example, what prevents me from doing something (stupid) like

Code:

 
for (int i=0;i<100;i++){
    launcher();
}

this is not about performance , it's about wasting 100 megabytes
for building stacks, creating and destroying 100 kernel objects AND
making the whole system slower by putting heavy weights on the system scheduler.
this is not a good design and not a smart resource management.

3) in the suggested design , we have no way of determining how many
threads are actually running, how many did we launched and how many are finished.
I wouldn't suggest a design like this in general, and specificly when
dealing with threads.

luckily, a Thread pool solves all of these issues by providing Task-based
API with smart resource management which promotes heavy rsources re-use