Question

Consider the following multi-threaded code segment (in a mix of C and pseudo-code), invoked by two processes $P1$ and $P2$, and each of the processes spawns two threads $T1$ and $T2$: 

int x = 0; // global 
Lock L1; // global 
main() { 
	create a thread to execute foo(); // Thread T1 
	create a thread to execute foo(); // Thread T2 
	wait for the two threads to finish execution; 
	print(x); } 
foo() { 
	int y = 0; 
	Acquire L1; 
	x = x + 1; 
	y = y + 1; 
	Release L1; 
	print(y); }  

Which of the following statement(s) is/are correct? 
 

• A. Both $P1$ and $P2$ will print the value of $x$ as $2$.
• B. At least one of $P1$ and $P2$ will print the value of $x$ as $4$.
• C. At least one of the threads will print the value of $y$ as $2$.
• D. Both $T1$ and $T2$, in both the processes, will print the value of $y$ as $1$.

Hint:

Global variables are shared among threads of the same process, but not across different processes. Local variables are private to each thread.

Answer 1

The Correct Option is A, D

Step 1: Scope of variables across processes and threads.
Each process ($P1$ and $P2$) has its own address space. Hence, the global variable $x$ and the lock $L1$ are shared between threads within a process but not shared across processes.

Step 2: Behaviour of variable $x$.
In each process, two threads $T1$ and $T2$ execute \texttt{foo()}. The increment operation on $x$ is protected by the lock $L1$, so there is no race condition.
Thus, in each process: \[ x = 0 \xrightarrow{\text{two increments}} x = 2 \] Therefore, both $P1$ and $P2$ will print $x = 2$. So, Option (A) is correct and Option (B) is false.

Step 3: Behaviour of variable $y$.
The variable $y$ is a local variable inside the function \texttt{foo()}. Each thread has its own separate instance of $y$, initialized to $0$.
Inside \texttt{foo()}, each thread executes: \[ y = y + 1 \] exactly once. Hence, each thread prints: \[ y = 1 \] There is no possibility of $y$ becoming $2$ in any thread.

Step 4: Evaluation of remaining options.
Option (C): False, since $y$ is local to each thread and incremented only once.
Option (D): True, because both $T1$ and $T2$ in both processes will print $y = 1$.

Step 5: Conclusion.
The correct statements are (A) and (D).