Re: code pattern for locking & unlocking
On 29/11/10 19:28, Goran wrote:
On Nov 29, 11:04 am, Maxim Yegorushkin<maxim.yegorush...@gmail.com>
wrote:
void someFunc()
{
// do some stuff
...
// now time to update share data
{
Lock myLock(data_mutex);
//use locked data
....
} // destructor called
// do more stuff
...
}
I would like to have something like the using keyword in c#.
Is there a way to fake it in C++ ?
The alternative to creating a scope just to unlock the mutex at a
particlular point, it may be simpler to provide unlock() function on the
lock, e.g.:
struct Lock
{
Mutex* mtx_;
Lock(Mutex& mtx) : mtx_(&mtx) { mtx_->lock(); }
~Lock() { this->unlock(); }
void unlock() {
if(mtx_) {
mtx_->unlock();
mtx_ = 0;
}
}
};
void someFunc()
{
Lock myLock(data_mutex);
// ... use locked data ...
myLock.unlock(); // unlock long before leaving the scope
// ... more code ...
}
Notice in the above how no artificial scope is introduced and
myLock.unlock() does exactly what it says.
I don't think that's good, not in the general case. It drastically
changes lock duration in face of exceptions.
Lock duration is the same since the destuctor still does unlock. The
difference is that there is no need for an extra scope when unlock() is
used.
> Without, lock is there
from ctor of lock to unlock(). With, it's from ctor to the end of the
scope.
And?
> However smart we think we are, we will mess it up ;-).
I don't understand you concern. Could you elaborate please?
Also, you introduced performance penalty (an if and an an assignment
to 0).
Quantify the impact please.
If that code is inline it is going to be optimized out. gcc, for
example, does this optimization even in debug mode.
http://en.wikipedia.org/wiki/Static_single_assignment_form