Lock Variable Synchronization Mechanism

17 Dec, 2021
Prerequisites – Process SynchronizationA lock variable provides the simplest synchronization mechanism for processes. Some noteworthy points regarding Lock Variables are- 
Its a software mechanism implemented in user mode, i.e. no support required from the Operating System.Its a busy waiting solution (keeps the CPU busy even when its technically waiting).It can be used for more than two processes.
Its a software mechanism implemented in user mode, i.e. no support required from the Operating System.
Its a busy waiting solution (keeps the CPU busy even when its technically waiting).
It can be used for more than two processes.
When Lock = 0 implies critical section is vacant (initial value ) and Lock = 1 implies critical section occupied.The pseudocode looks something like this – 
Entry section - while(lock != 0);
                Lock = 1;
//critical section
Exit section - Lock = 0;
A more formal approach to the Lock Variable method for process synchronization can be seen in the following code snippet :
C
char buffer[SIZE];int count = 0,    start = 0,    end = 0;struct lock l; // initialize lock variablelock_init(&l); void put(char c){     // entry section    lock_acquire(&l);     // critical section begins    while (count == SIZE) {         lock_release(&l);        lock_acquire(&l);    }     count++;    buffer[start] = c;    start++;     if (start == SIZE) {         start = 0;    }     // critical section ends    // exit section    lock_release(&l);} char get(){     char c;     // entry section    lock_acquire(&l);     // critical section begins    while (count == 0) {         lock_release(&l);        lock_acquire(&l);    }     count--;    c = buffer[end];    end++;     if (end == SIZE) {         end = 0;    }     // critical section ends    // exit section    lock_release(&l);     return c;}
Here we can see a classic implementation of the reader-writer’s problem. The buffer here is the shared memory and many processes are either trying to read or write a character to it. To prevent any ambiguity of data we restrict concurrent access by using a lock variable. We have also applied a constraint on the number of readers/writers that can have access.Now every Synchronization mechanism is judged on the basis of three primary parameters : 
Mutual Exclusion.Progress.Bounded Waiting.
Mutual Exclusion.
Progress.
Bounded Waiting.
Of which mutual exclusion is the most important of all parameters. The Lock Variable doesn’t provide mutual exclusion in some cases. This fact can be best verified by writing its pseudo-code in the form of an assembly language code as given below.
1. Load Lock, R0 ; (Store the value of Lock in Register R0.)
2. CMP R0, #0 ; (Compare the value of register R0 with 0.)
3. JNZ Step 1 ; (Jump to step 1 if value of R0 is not 0.)
4. Store #1, Lock ; (Set new value of Lock as 1.)
Enter critical section
5. Store #0, Lock ; (Set the value of lock as 0 again.)
Now let’s suppose that processes P1 and P2 are competing for Critical Section and their sequence of execution be as follows (initial value of Lock = 0) –
P1 executes statement 1 and gets pre-empted.P2 executes statement 1, 2, 3, 4 and enters Critical Section and gets pre-empted.P1 executes statement 2, 3, 4 and also enters Critical Section.
P1 executes statement 1 and gets pre-empted.
P2 executes statement 1, 2, 3, 4 and enters Critical Section and gets pre-empted.
P1 executes statement 2, 3, 4 and also enters Critical Section.
Here initially the R0 of process P1 stores lock value as 0 but fails to update the lock value as 1. So when P2 executes it also finds the LOCK value as 0 and enters Critical Section by setting LOCK value as 1. But the real problem arises when P1 executes again it doesn’t check the updated value of Lock. It only checks the previous value stored in R0 which was 0 and it enters critical section.This is only one possible sequence of execution among many others. Some may even provide mutual exclusion but we cannot dwell on that. According to murphy’s law “Anything that can go wrong will go wrong“. So like all easy things the Lock Variable Synchronization method comes with its fair share of Demerits but its a good starting point for us to develop better Synchronization Algorithms to take care of the problems that we face here. This article is contributed by Siddhant Bajaj 2. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
avtarkumar719
GATE CS
Operating Systems
Operating Systems
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Differences between TCP and UDP
Types of Network Topology
Difference between Clustered and Non-clustered index
Difference between Process and Thread
Three address code in Compiler
Banker's Algorithm in Operating System
Disk Scheduling Algorithms
Paging in Operating System
File Allocation Methods
CPU Scheduling in Operating Systems