ptg10805159398 Threads Chapter 11
read the variable, thread B acquires a lock. Similarly,when thread A updates the
variable, it acquires the same lock. Thus thread B will be unable to read the variable
until thread A releases the lock.Thread Areadwrite 1write 2Thread BreadreadtimeFigure 11.8 Twothreads synchronizing memory accessWe also need to synchronize two or morethreads that might try to modify the same
variable at the same time. Consider the case in which we increment a variable
(Figure11.9). The increment operation is usually broken down into three steps.- Read the memory location into a register.
- Increment the value in the register.
- Write the new value back to the memory location.
If two threads try to increment the same variable at almost the same time without
synchronizing with each other,the results can be inconsistent.Youend up with a value
that is either one or two greater than before, depending on the value observed when the
second thread starts its operation. If the second thread performs step 1 beforethe first
thread performs step 3, the second thread will read the same initial value as the first
thread, increment it, and write it back, with no net effect.
If the modification is atomic, then thereisn’t a race. In the previous example, if the
increment takes only one memory cycle, then no race exists. If our data always appears
to be sequentially consistent,then we need no additional synchronization. Our
operations aresequentially consistent when multiple threads can’t observe
inconsistencies in our data. In modern computer systems, memory accesses take
multiple bus cycles, and multiprocessors generally interleave bus cycles among
multiple processors, so we aren’t guaranteed that our data is sequentially consistent.