Mutex/Lock

[Chris Forone]

hello group,

is there a chance for other functions to get the lock if i have
following loop:

while (running)
{
Lock local(mutex);
}

if not, is it enough to change scope:

while (running)
{
{
Lock local(mutex);
}
}

thanx & hand, chris

[Gianni Mariani]

Chris Forone wrote:

hello group,

is there a chance for other functions to get the lock if i have
following loop:

while (running)
{
Lock local(mutex);
}

yes - that code is the same as

while (running) {
mutex.lock();
mutex.unlock();
}

>
if not, is it enough to change scope:

while (running)
{
{
Lock local(mutex);
}
}

Makes no difference.

[Paul Brettschneider]

Chris Forone wrote:

hello group,

is there a chance for other functions to get the lock if i have
following loop:

while (running)
{
Lock local(mutex);
}

if not, is it enough to change scope:

while (running)
{
{
Lock local(mutex);
}
}

You probably want:

{
Lock local(mutex);
while(running)
{
...
}
}

[Chris Thomasson]

"Paul Brettschneider" <pa************ *****@yahoo.frw rote in message
news:92******** *************** ***@news.chello .at...

Chris Forone wrote:

>hello group,

is there a chance for other functions to get the lock if i have
following loop:

while (running)
{
Lock local(mutex);
}

if not, is it enough to change scope:

while (running)
{
{
Lock local(mutex);
}
}

You probably want:

{
Lock local(mutex);
while(running)
{
...
}
}

Why?

[Chris Thomasson]

"Gianni Mariani" <gi*******@mari ani.wswrote in message
news:48******** @news.mel.dft.c om.au...

Chris Forone wrote:

>hello group,

is there a chance for other functions to get the lock if i have following
loop:

while (running)
{
Lock local(mutex);
}

yes - that code is the same as

while (running) {
mutex.lock();
mutex.unlock();
}

You mean that code is the same as:
while (running) {
try {
mutex.lock();
} catch (...) {
mutex.unlock();
throw;
}
mutex.unlock();
}
Right?
[...]

[Chris Forone]

Paul Brettschneider schrieb:

Chris Forone wrote:

>hello group,

is there a chance for other functions to get the lock if i have
following loop:

while (running)
{
Lock local(mutex);
}

if not, is it enough to change scope:

while (running)
{
{
Lock local(mutex);
}
}

You probably want:

{
Lock local(mutex);
while(running)
{
...
}
}

No, the first version is the one i need. its to suspend/resume in a well
defined position in code. So i had:

bool Resume()
{
Lock local(mutex);
// resume thread
}

bool Suspend()
{
Lock local(mutex);
// suspend thread
}

bool Exit()
{
Lock local(mutex);
// here was my dl, because of wait for thread termination :-)
}

void Proc()
{
while (active)
{
Lock local(mutex);
// do things
}
}

now my Exit looks:

bool Exit()
{
mutex.Acquire() ;

if (active)
{
active = false, mutex.Release() ;
// wait for thread termination :-)))
}

mutex.Release() ;
}

it functs, hope it is waterproof...

thanks & hand, chris

ps: Ideas for better doing it are very welcome!

[Chris Forone]

Errata:

bool Exit()
{
mutex.Acquire() ;

if (active)
{
active = false;
mutex.Release() ;
// wait for thread termination :-)))
}

mutex.Release() ;
}

if i write:

active = false, mutex.Release()

i think, the mutex is first released -error

is this right?

thanx & hand, chris

[Paul Brettschneider]

Chris Forone wrote:

Paul Brettschneider schrieb:

>Chris Forone wrote:

>>hello group,

is there a chance for other functions to get the lock if i have
following loop:

while (running)
{
Lock local(mutex);
}

if not, is it enough to change scope:

while (running)
{
{
Lock local(mutex);
}
}

You probably want:

{
Lock local(mutex);
while(running)
{
...
}
}

No, the first version is the one i need. its to suspend/resume in a well
defined position in code. So i had:

Ah. I misread your question. I think what you want is a notify/signal
mechanism, which should be implemented for every thread package. (In
pthreads it's the pthread_cond_* functions.)

[James Kanze]

On May 31, 10:39 am, Chris Forone <[e-mail] te:

Errata:

bool Exit()
{
mutex.Acquire() ;

if (active)
{
active = false;
mutex.Release() ;
// wait for thread termination :-)))
}

mutex.Release() ;
}

if i write:

active = false, mutex.Release()

i think, the mutex is first released -error

is this right?

No. There's a sequence point at the comma, so all side effects
of the preceding expression must be finished before any side
effects of the following occur.

I do wonder about your code, however. You really need to
recover the mutex before the end of the if---otherwise, you'll
release it twice. And how do you wait for thread termination:
with a join, or with some sort of global thread counter? In the
latter case, you'll need the mutex to read it as well.

I generally use something like:

void
requestTerminat ion()
{
ScopedLock lock( terminateFlagMu tex ) ;
terminateReques ted = true ;
}

void
waitForAllThrea dsToTerminate()
{
ScopedLock lock( threadCountMute x ) ;
while ( threadCount != 0 ) {
threadCountCond ition.wait( lock ) ;
}
}

void
terminate()
{
requestTerminat ion() ;
waitForAllThrea dsToTerminate() ;
}

with:

void
endOfThread()
{
ScopedLock lock( threadCountMute x ) ;
-- threadCount ;
threadCountCond ition.notify() ;
}

at the end of each thread. (Note that this does require some
care when starting threads, since a race condition can occur
there if you're not careful. In my case, it's not a problem,
because all of the threads are always started by the main
thread, which is also the only thread which will call
terminate(), but if other running threads might start a thread
while you're calling terminate, you'll have to add some
additional logic in thread start-up to avoid the race.)

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Chris Forone]

James Kanze schrieb:

On May 31, 10:39 am, Chris Forone <[e-mail] te:

>Errata:

>bool Exit()
{
mutex.Acquire() ;

> if (active)
{
active = false;
mutex.Release() ;
// wait for thread termination :-)))
}

> mutex.Release() ;
}

>if i write:

>active = false, mutex.Release()

>i think, the mutex is first released -error

>is this right?

No. There's a sequence point at the comma, so all side effects
of the preceding expression must be finished before any side
effects of the following occur.

I do wonder about your code, however. You really need to
recover the mutex before the end of the if---otherwise, you'll
release it twice. And how do you wait for thread termination:
with a join, or with some sort of global thread counter? In the
latter case, you'll need the mutex to read it as well.

Thanx for the example. The wait is done with the win32 function
WaitForSingleOb ject() with no timeout. Excuse me for the incomplete example:

bool Exit()
{
mutex.Acquire() ;

if (active)
{
active = false;
mutex.Release() ;

return WaitForSingleOb ject(thread, INFINITE) == WAIT_OBJECT_0;
}

mutex.Release() ;
}

The sideeffect-thing i dont understand...

What about:

return someVar1 == 10 &&
someVar2 != 20 &&
(someVar3 = someFunc()) == true;

and

return (someVar1 == 10) &&
(someVar2 != 20) &&
(someVar3 = someFunc()) == true;

thanx & hand, chris