04 Sep 94, Craig Swanson writes to Jari Laaksonen:

 > 2) Any variables or resources that may have to be accessed by more
 >    than one thread at a time MUST be protected by a semaphore
 >    or some other mechanism in order to avoid corrupting the data
 >    structures a thread context switch occurs such that one thread
 >    hasn't finished modifying a data structure and then the next
 >    thread starts modifying it while it is in an inconsistent state.

This is NOT correct.  While in many cases it is true that you need to use
protection mechanisms to prevent race conditions, it is not ALWAYS true. 
Many operations are atomic or will not produce a race condition even if it
is not atomic.

For example, I use a variation on this code all the time:

int     thread_finished;

void function_in_one_thread(void *dummy)
{
    /* Some initialization goes here */
    do
    {
        /* Some processing goes here */
    } while(!thread_finished);
    /* Some exit processing goes here */
}


void function_in_other_thread(void)
{
    thread_finished = 0;
    _beginthread(function_in_one_thread, NULL 131072, NULL);
    getch();
    thread_finished = 1;
    /* usually I put a wait for the thread to terminate here */
}

In this case, access to the thread_finished variable does NOT have to be
protected by a semaphore because both reading and writing integers are
atomic operations. Read-modify-write is NOT an atomic operation, but I'm
not doing
that here.

- Jon

--- GoldED/2 2.42.G0214