CareerCup

Why would P1 copy var again in step 4? It has already copied in step 1.

If the var is 0 initially, min value can be 2 and max can be 200.

To answer Huwanda's question, here is what can happen to get the value of 2.

P1 and P2 both read var = 0 in their registers. P1 gets CPU, increments 99 times, so var = 99, cached value of var = 99, however, P2 register has this value = 0.
P1 gets context switched out and P2 gets CPU. Because P2 has already a copy of var in its register, it will increment it to make it 1. When P1 writes it in its cache, cache overwrites P1's value. Now cache contains var = 1.
P2 gets context switched out and P1 gets CPU. P1 reads var = 1 in its register from cache and gets context switched out.
P2 gets CPU, copies var in its register and increments it 100 times making var = 100 in cache. However, var value already copied in P1's register = 1.
P2 finishes, P1 gets CPU, already has var = 1 in its registers (if it reads from cache, it will read 100, but since it's already copied in register, it won''t consult cache). P1 increments var to 2, overwrites the value in the cache which was 100 before. Final value = 2.

Cache can be replaced with memory (RAM) in above analysis, because they are always kept coherent in hardware architecture. However, variables copied in registers can do the damage if memory locations are not properly synchronized.

@Hariharan. Do you mean
say initial value of var be var_ini

P1 copies var to reg_p1 (swap to P2)
P2 copies var to reg_p2 (swap to P1)

The copy instruction of P1 already got executed (here does not matter)
P1 increments reg_p1
stores it in var
does the following 3 steps 98 times
load var to reg_p1
P1 increments reg_p1
stores it in var

So the value is in var is var_ini + 99 (swap to P2)

The copy instruction of P2 already got executed
P2 increments reg_p2
stores it in var

So the value is in var is var_ini + 1 (swap to P1)

P1 comes and loads var to reg_p1
reg_p1 is now var_ini+1 (swap to P2)

Now P2 comes and does the following 3 steps 99 times
load var to reg_p2
increments reg_p2
stores it in var

Now P2 completed its turn, and P1 will get executed
The copy instruction of P1 already got executed and reg_p1 is now var_int+1
P1 increments reg_p1
stores it in var

now the var is var_ini+2

Now P1 also completed its turn.

And the final value of var is var_ini+2

I think Hariharan's answer is the correct one. My explanation is under his comment.

Even in single processor there could be time sharing.
eg.
Threads T1 reads the number say "1". times up before it could actually increase the number. T1 waits for the next time slot.
Thread T2 reads the number "1". and increases the number and assign the new value to "2"
T1 gets the time slot. T1 had read the value to be 1. so assign the new value to be 2.

in this operation the value of the variable will be increase by just 1 even if 2 threads are working simultaneously.

Thus the minimum possible value in the will be 100 and max value will be 200

But as 2 threads belong to same program, program cannot be shared into 2 CPUs. Hence, min and max in any case will be 200.

Shantanu: really?
"But as 2 threads belong to same program, program cannot be shared into 2 CPUs." Where did this come from?

Max is 120 because each thread has their own copy of i. I have modified the code a bit and now Max = 220

public class TwoThreadAdding100Item {

	public static void main(String args[]) {
		Incrementor in = new Incrementor(20);
		new Thread(new MyRunnable(in), "Thread 1").start();
		new Thread(new MyRunnable(in), "Thread 2").start();
	}

	static class MyRunnable implements Runnable {
		
	Incrementor in;	
		public MyRunnable(Incrementor in) {
			this.in=in;
		}
		@Override
		public void run() 
		{
			System.out.println(Thread.currentThread().getName() + " : " + in.getvalue()); 	
			for (int j = 0; j < 100; j++) {
				in.increment();
			}
			System.out.println(Thread.currentThread().getName() + " : " + in.getvalue()); 
		}

	}
	
	static class Incrementor
	{
		Integer i ;
		
		Incrementor(Integer i)
		{
			this.i=i;
		}
		
		public void increment()
		{
			i++;
		}
		public int getvalue()
		{
			return i;
		}
	}
}