any function for entering critical section?

hi
my question is:
if there are many vars shared between threads for condition checking
such as
if(shared_var1 > 0)
{...}
because other thread may do this at the same time
how to guarantee that threads exclusively access the var

i feel a bit troublesome to define respective mutex for every shared var that may be access by more than one thread. so, is there any function can do this.

Originally Posted by ebd hi my question is: if there are many vars shared between threads for condition checking such as if(shared_var1 > 0) {...} because other thread may do this at the same time how to guarantee that threads exclusively access the var i feel a bit troublesome to define respective mutex for every shared var that may be access by more than one thread. so, is there any function can do this.

Don't double-post the same question twice.

This was the original - I closed the dupe.

i feel a bit troublesome to define respective mutex for every shared var that may be access by more than one thread. so, is there any function can do this.

1. If you just want a 'critical section' type functionality, then you only need to define a single mutex and use that for all your variables (even define a couple of functions to lock and unlock the mutex). You won't get quite as good a level of concurrency, but if the program doesn't spend much time inside critical sections you will hardly notice a difference using a single mutex vs separate ones.

2. If your problem is speed, then use a spin lock. But it would be rare that you should need these in a user space program.

3. If you are using a language with generic programming facilities like C++, you could make use of a templated type that creates the mutex in the constructor and makes lock/unlock calls for any of the accessor functions that you implement. This also means much neater code when the shared variable is accessed inside a conditional expression.

if your shared vars are simple numbers you could also use atomic operations, gcc 4.1.x and above supports native atomic operations (not available on all platforms so not completely portable).

http://www.alexonlinux.com/multithre...omic-variables
http://gcc.gnu.org/onlinedocs/gcc-4....-Builtins.html
http://golubenco.org/blog/atomic-operations/

There is no reason you need to define a mutex for each variable. In fact, if you are working with related variables it is inefficient to do that.

At the very simplest, define one for the entire program.

A more common method is to include a mutex in each structure that you are manipulating. Often this is passed into each thread when it is created via pthread_create().

There may be gcc-specific methods to handle critical sections, but for portable code just use mutexes.

Without knowing the details of the OP's requirements I would personally say that using one mutex/synchronisation method for multiple variable is a bad idea ™. You really should only lock for something you need, without blocking anything else from using the other variable which you do not need. CAS could be used but I would only use it as an optimisation and not the default.

Don't double-post the same question twice.

So is that four posts ?

Originally Posted by TB0ne Don't double-post the same question twice.

sorry, it was just by mistake
my explorer became busy state the first time i posted
so i stopped the explorer and posted it again, not aware of the post having been posted

thank neonsignal a lot
your reply is helpful

Originally Posted by dmail Without knowing the details of the OP's requirements I would personally say that using one mutex/synchronisation method for multiple variable is a bad idea ™. You really should only lock for something you need, without blocking anything else from using the other variable which you do not need. CAS could be used but I would only use it as an optimisation and not the default. So is that four posts ?

what do you mean by CAS? I'm a newbie

Originally Posted by estabroo if your shared vars are simple numbers you could also use atomic operations, gcc 4.1.x and above supports native atomic operations (not available on all platforms so not completely portable). http://www.alexonlinux.com/multithre...omic-variables http://gcc.gnu.org/onlinedocs/gcc-4....-Builtins.html http://golubenco.org/blog/atomic-operations/

your post is really professional, thanks

Originally Posted by ebd what do you mean by CAS? I'm a newbie

I have not read the links posted by estabroo (well not just now anyway) yet I would find it hard to believe they do not use the term CAS.

dmail - They used compare and exchange instead of compare and swap. I'm guessing that the x86 asm op for it is cmpxchg.