PC>
  > ULONG  someFn()
  > {
  >   ULONG rc = 0;
  >   requestMutexSem();
  >   rc = something;
  >   releaseMutexSem();
  >
  >   return rc;  // A calling thread is pre-empted here before returning rc.
  >
  >               // A second threads comes along and completes the
  >               // function before the first thread has finished,
  >               // thus causing rc to contain invalid data.
  >               // Is this possible?
  > }
PC>

  Yes; if, say, a second higher-priority thread were blocked at the start
  of the same function, it could be unblocked by the release of the
  semaphore, and run the whole function before the first thread were run
  again.

  However, whether this makes `rc' invalid is dependent from the nature of
  the function.  Good multithreaded design involves working under the
  assumption that all information gained during an atomic operation may go
  out of date immediately, because of the actions of other, concurrent,
  threads.

  If this causes problems with code based upon the results obtained, then
  your granularity is too fine, and should be coarsened.  For example,
  assume that `someFn' above were returning whether a list was empty or
  not, that the calling code were

    if (someFn())                           // List is empty
        delete the_list, the_list = 0 ;     // So destroy the list

  and than it was not desired that a non-empty list be destroyed.

  In this case, the entire `if' statement should be an atomic operation,
  not just the test function, otherwise another thread could add elements
  to the list in between the time that the test function exits its mutex
  section and the time that the first thread actually destroys the list.

  > JdeBP <
___
 X MegaMail 2.10 #0:

--- Maximus/2 3.01