hi there... what is the scope of locked variables? assuming that i declare a mutex in say a class scope.. and then lock it in some inner scope - say in a function.. what variables get locked? is it all the variables which are in the scope of the declaration (ie all the variables which are declared in the class)? or is it only the ones which are being used in that particular function (so that perhaps another thread could use the rest at "the same time")? for example: class Class1 { public: Class1::Class1(); ~Class1::Class1(); void f(int new) { boost::mutex::scoped_lock scoped_lock(mutex_outer) ; var1 = new; } void g(int new) { boos::mutex mutex_inner; boost::mutex::scoped_lock scoped_lock(mutex_inner) ; var1 = new; } private: boost::mutex mutex_outer; Class2 some_member_object; int var1; int var2; }; what gets locked when f() is called? when should i use g()? how do I go about just locking say var1 but NOT var2? if i lock the mutex in this class scope, does that mean that all the variables in some_member_object are locked as well? also, should i set up locks anytime i am using an object which might be accesses by another thread (even if I am just reading it) or is it enough to only lock variables when i am changing them? i know that's a lot of questions, but any help would be greatly appreciated. cheers peter
Peter G said:
hi there...
what is the scope of locked variables? assuming that i declare a mutex in say a class scope.. and then lock it in some inner scope - say in a function.. what variables get locked? is it all the variables which are in the scope of the declaration (ie all the variables which are declared in the class)? or is it only the ones which are being used in that particular function (so that perhaps another thread could use the rest at "the same time")?
for example:
class Class1 { public:
Class1::Class1(); ~Class1::Class1();
void f(int new) { boost::mutex::scoped_lock scoped_lock(mutex_outer) ; var1 = new; }
void g(int new) { boos::mutex mutex_inner; boost::mutex::scoped_lock scoped_lock(mutex_inner) ; var1 = new; } private:
boost::mutex mutex_outer; Class2 some_member_object; int var1; int var2; };
what gets locked when f() is called?
The "mutex_outer" variable, nothing more, nothing less.
when should i use g()?
Never, because it's invalid C++ ;). But seriously, fix the syntax problems and I'd still say never. Every time g() is called you get a new "mutex_inner", so the lock is pointless.
how do I go about just locking say var1 but NOT var2?
You don't lock variables, you lock mutexes. What variables a mutex protects is a logical part of the code, not something enforced by the syntax/semantics. IOW, the mutex protects only what you want it to protect, nothing more, nothing less, and any coding errors on your part can lead to race conditions because you've failed to live up to the logical contract *you* specified for the mutex. At this point things are so confused, I'm not sure how to word things so that I don't confuse you more. If you think a variable should be protected by a mutex, *always* lock that mutex before using the variable. If not, then realize the variable is not protected and should not be accessed from multiple threads. Protecting a variable with multiple mutexes is also a very bad idea, and will result in race conditions or deadlock in most cases (and inefficient code in the other cases).
if i lock the mutex in this class scope, does that mean that all the variables in some_member_object are locked as well?
Only if you consider them to be.
also, should i set up locks anytime i am using an object which might be accesses by another thread (even if I am just reading it) or is it enough to only lock variables when i am changing them?
No, locking only when you write is not enough. Fail to lock when you read and you may read data that's only partially "correct", i.e. the invariants may be broken. -- William E. Kempf
agghhh it clicked... when i lock a mutex, all i am doing is preventing another thread from executing the code that follows until the mutex is unlocked.. regardless of what that code does... i thought of this whole threading business in a wrong way... thanks william
Peter G wrote:
agghhh it clicked... when i lock a mutex, all i am doing is preventing another thread from executing the code that follows until the mutex is unlocked.. regardless of what that code does...
I think your on the right lines. When you lock a mutex, you are preventing any other thread from acquiring a lock on the same mutex until the thread that has locked it successfully, releases that lock. The thread attempting to lock an already locked mutex will block until the mutex is unlocked. Unless you use another type of mutex (e.g. try_mutex or timed_mutex) Cheers Russell
participants (3)
-
Peter G -
Russell Hind
-
William E. Kempf