Another possible technique for mutual exclusion is to use busy waiting. We can introduce a Boolean variable called mutex that is set to true when an activity is in a critical section, to false otherwise. A process executes the following code before it enters a critical section:
while mutex do
do nothing
end;
mutex <- true;
and the following code when it exits the region:
mutex <- false
Unfortunately, this code is wrong. If two processes start executing the while loop at the same time, they might both get past the loop and enter their regions. The problem is that the checking and setting of the Boolean are done in two statements. A process that has tested the Boolean variable may be rescheduled before it sets the variable.
Let us assume that the `test and set' can be done in one instruction, so that the code looks like:
while (TestAndSet(mutex)) do
do nothing
end;
where TestAndSet looks like:
atomic function TestAndSet (var Lock: Boolean): Boolean;
begin
TestAndSet <- Lock;
Lock <- true
end TestAndSet;
The solution is not good since the CPU may spend a lot of time
executing the while loop which does no useful work.
In particular,
if the `waiting' process is a high priority process waiting for a lower priority
process to set the Boolean variable to false,
the CPU will spend all its time executing the loop.
However several computers offer such an instruction as the low-level
alternative to disabling interrupts in a multiprocessor system.