互斥保护宏

Question

This is one of my first posts on this community, so please bear with me.

Is there a way to mutex protect a macro, in the macro itself.

For example,

#define FUNCTION_ \
doSomething()

Basically, I'm looking to do something like this

#define FUNCTION_ \
mutex.lock \
doSomething() \
mutex.unlock

For further information, the macros are all declared within a header file, by themselves ( no namespace or class), which handles calls to an API. We are utilizing C++. This header file is utilized by multiple projects therefore an overhaul of the macro itself is out of the question. For more detail on the Macro, it wraps calls to log4CXX.log4CXX is threadsafe; however, two threads utilizing this macro, who make a write call at the same time is not thread safe. Helgrind complains when running Valgrind about that. Mutex protecting the macro in the code fixes the problem, but instead of mutex protection every single call, have the macro protect its own call.

Answer 1

If you have already this

#define FUNCTION_ \
doSomething()

and if there is really no chance to stop such macro madness, then at least dont take it one step further. If you need a lock in doSomething() then the easiest would be to acquire the lock in the function:

void doSomething() {
    mutex.lock();
    /* .... */ 
    mutex.unlock();
}

or if for some reason you cannot change the function then wrap it

#define FUNCTION_ \
doSoemthingLocked()

void doSomethingLocked() {
    mutex.lock();
    doSomething();
    mutex.unlock();
}

(maybe declared as inline if you need to put it in a header, and maybe passing a reference to the mutex as parameter)

Answer 2

You have the code. Just cover it up. This should do:

#define FUNCTION_ \
do { \
    mutex.lock() \
    doSomething() \
    mutex.unlock() \
} while(0)

Answer 3

The solution for the problem is as follows:

#define FUNCTION_ \
{ \
   mutex.lock(); \
   doSomething(); \
   mutex.unlock(); \
} \

However, for the mutex itself I have a mutex that wraps the pthread_mutex_t so in this situation I declared the mutex as:

extern Mutex mutex;

Then in a .cpp file:

#include <headerFile.hpp>

Mutex mutex;

This creates a single instance of the mutex and prevents issues with multiple instances of the same name being discovered.