Why should the thread function of a class be made static to be accessible in the same class?

Question

My error:

error: cannot convert 'MainWindow::producerThreadFunction' from type 'void* (MainWindow::)(void*)' to type 'void* (*)(void*)'
     if (pthread_create (&producer, NULL, producerThreadFunction, NULL))
                                                                      ^

Header file:

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QApplication>

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <iostream>
#include <QDebug>

class MainWindow : public QMainWindow
{
    Q_OBJECT

    pthread_mutex_t mutexVariable = PTHREAD_MUTEX_INITIALIZER;
    pthread_cond_t  conditionVariable = PTHREAD_COND_INITIALIZER;

    QList <int> queueLIFO;

public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();

    //  This function is run by the thread `Producer`.
    void *producerThreadFunction (void *arg);

    //  This function is run by the thread `Consumer`.
    void *consumerThreadFunction (void *arg);

    int start ();
};

#endif // MAINWINDOW_H

Source file: (function where the error occurs)

int MainWindow :: start()
{
    pthread_t producer;
    pthread_t consumer;

    if (pthread_create (&producer, NULL, producerThreadFunction, NULL))
    {
        fprintf (stderr, "Error creating thread Producer\n");
        return 1;
    }
if (pthread_create (&consumer, NULL, consumerThreadFunction, NULL))
{
    fprintf (stderr, "Error creating thread Consumer\n");
    return 1;
}

if (pthread_join (producer, NULL))
{
    fprintf (stderr, "Error joining thread Producer\n");
    return 2;
}

if (pthread_join (consumer, NULL))
{
    fprintf (stderr, "Error joining thread Consumer\n");
    return 2;
}

return 0;

}

According to this thread, the solution is to make the producerThreadFunction static.

Why should the thread function of a class be made static to be accessible in the same class?

That function is the member function of that class. Why cannot I access it directly?

Answer 1

pthread_create expects a function pointer, not a pointer to a member function. These are very different types in C++ because member function pointers include an implicit this pointer. In practice, static member functions are equivalent to a non-member function, so that works fine (N.B. this is not technically true according to the standard - see below).

If pthread were a C++ library, it would likely take an std::function (or, before C++11, a boost::function) which can accept a variety of function-like objects; e.g. function pointer, member function pointers, or functor classes. However, since pthread is a C library, however, you're stuck writing a static function and manually passing the this pointer as an argument.

You should seriously consider using std::thread (or, before C++11, boost::thread) instead of pthreads. The same synchronization primitives are available as are available in pthreads, e.g. std::condition_variable. The std::thread constructor can directly accept a member function pointer:

std::thread producer(&MainWindow::producerThreadFunction, this);

The Standard

C and C++ may use different calling conventions. This means that it is not safe to call a C++ function from C code unless it is wrapped in an extern "C" block. However, as this answer on StackOverflow points out, C++11 7.5/4 "Linkage specifications" says:

A C language linkage is ignored in determining the language linkage of the names of class members and the function type of class member functions.

Therefore, it is not guaranteed to work by the standard. The only standards compliant option is to put the code in a non-member function which, internally, calls a member function:

extern "C" {

void producerThreadFunctionWrapper(void *arg)
{
    static_cast<MainWindow *>(arg)->producerThreadFunction();
}

} // extern "C"

// ...

pthread_create(&consumer, NULL, consumerThreadFunctionWrapper, this);

In Practice

In practice, I have never encountered an architecture/compiler where static member functions do not use the C linkage. The answer to question 33.2 in the C++FQA humorously makes the same point:

Regarding the static-members-as-callbacks issue: if your implementation uses different binary calling conventions for C functions and C++ static member functions, call the support and inform them that their developers consume mind-altering chemicals at work.

Caveat emptor, however, there are a few reports on StackOverflow (e.g. in 32 bit Visual Studio) of people being burned by this. The safest option is to use std::thread or write an extern "C" wrapper for your callbacks.

Answer 2

Since we are almost done with 2015, it is time to throw C++2003 away. The best way to call your thread is following:

int MainWindow :: start()
{
    std::thread producer(&MainWindow::producerThreadFunction, this);
    ...

See how easy it is? And no need to worry about static member functions at all!