C++ Mutex and Function Arguments

Question

Question Motivation

I am using mutexes to protect some variables in a function which is the entry point of a set of threads. I think the mutex will protect the variables which are in the same scope, but will it protect the function arguments? Especially if the arguments are pointers.

Example Code

Edit: Mutex is declared in main, otherwise it doesn't work - silly me.

I have a function like this:

void threadfunction(int index, char* const flag)
{
    //std::mutex m;
    std::lock_guard<std::mutex> lock(m);

    // Is this thread safe?
    if(*flag) { *flag = 0; index ++; }
}

int main()
{
    std::mutex m;
    std::vector<std::thread> threadvec;
    threadvec.push_back(std::thread(threadfunction)); // Or whatever it is
    ... join ...
}

I guess you can see the problem: Since the arguments are in the same scope of the mutex, I would assume index is protected. However, although I would assume the address stored in 'char* const flag' is thread-safe, I am guessing that '*flag' is not. is this correct, and is there a solution?

Thanks

PS: Sorry to anyone who edits the question and has to deal with my horrendous attempt at html.

Instead of `` tags, please use the Markdown code formatting facilities. See here: http://stackoverflow.com/editing-help#code. I took the liberty of editing it your post this time. — R. Martinho Fernandes, Jul 09 '13 at 14:13
Mutex needs to be shared among all threads. Your code will create a new local mutex for every thread - this will guard nothing. — YK1, Jul 09 '13 at 14:25
Ah Thanks @YK1 - I will put mutex in main. Will this protect the char* if I also declare the char* in main? — FreelanceConsultant, Jul 09 '13 at 14:29
@EdwardBird: char* (or any other variable) will be protected only when you access it in the lock context of the mutex - from wherever you access it. So, answering your question in the comment, if `threadfunction` is the only place you access it, then it is protected. If you access it from somewhere else too, make sure you lock the same mutex there as well. — YK1, Jul 09 '13 at 14:34

score 1 · Answer 1 · answered Jul 09 '13 at 14:13

1

Index is not "protected" but it's a local variable so there's nothing to protect. You are correct in being concerned about the contents of flag however. Your mutex prevents other threads from running the main body of this function but it does not prevent other code from accessing the memory of flag (assuming they have its address).

answered Jul 09 '13 at 14:13

mah

39,056
9
76
93

2

If the mutex was *static* it would prevent other threads from running the main body of the function. A local mutex constructed on the stack does nothing - other threads can't even access it. – Casey Jul 09 '13 at 14:23
Thanks, I didn't see this flaw. I have moved the mutex to main – FreelanceConsultant Jul 09 '13 at 14:32

score 1 · Answer 2 · answered Jul 09 '13 at 15:18

A mutex does not protect variables, it protects sections of code. If all sections of code which access the data are protected by the mutex, the data is protected. If there is any section of code which accesses the code without holding the mutex, then you have a race condition, and undefined behavior. (In other words, you need to use the same mutex when you set *flag.)

score 0 · Answer 3 · answered Jul 09 '13 at 15:42

For the actual code I was working on, I declared the mutex 'std::mutex mMutex' in the code with the variables which needed protection.

Then whenever a read/write to any of these variables was required, the mutex was locked then unlocked afterwards.

Probably not exception safe, but it seems to be working.

C++ Mutex and Function Arguments

Question Motivation

Example Code

3 Answers3