Java MultiThreading skips loop and gives wrong result

Question

Java MultiThreading skips loop and gives wrong result

package Threading;

class DemoThread extends Thread{   //Thread Class   
    static int count=0;   // variable incremented by both the threads

    public DemoThread(String name) {
        // TODO Auto-generated constructor stub
        super(name);
    }

    public void run() { 
        for(int i=0;i<100000;i++) {
            count++;
            System.out.println(Thread.currentThread()+"Count"+count);  // print thread operating on count variable
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }           
        }       
    }   
}


public class MyThreadClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub      
        DemoThread t1=new DemoThread("T1");
        DemoThread t2=new DemoThread("T2");
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();  //allowing both the threads to complee before main thread
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("Main Thread ends"+DemoThread.count);  //final value of count        
    }
}

The final value of count should be 199998 but it is not giving the desired result. Why the threads are missing the loops ???

Answer 1

It happened because Thread T1 and T2 will update count at the same time (concurrency) like that:

Thread[T1,5,main]Count10
Thread[T2,5,main]Count10
Thread[T1,5,main]Count12
Thread[T2,5,main]Count12
Thread[T2,5,main]Count14
Thread[T1,5,main]Count14
Thread[T1,5,main]Count15
Thread[T2,5,main]Count16

You should use AtomicInteger

And update your code:

static int count=0; to static AtomicInteger count= new AtomicInteger();

count++; to count.incrementAndGet();

Answer 2

You must use java.util.concurrent.atomic.AtomicInteger and not a shared static int variable.

Answer 3

Problem

In Java, multi threading introduces asynchronous behavior to your programs, you must enforce synchronicity when you need it.

Without synchronization, nothing stops a thread to access from calling a same method, on same object at the same time. This is known as Race Condition, because threads are racing each other to complete the method.

The output to your program:

The first line of the output printed 2!? This is because t1 wrote count's value and was preempted before it could print it. Note that for a thread to be preempted it need not go into sleep. OS does this neverthless.

If you notice the 1^st line and 4^th line you can see the inconsistency. This kind of inconsistency becomes unpredictable in huge programs.

Here are end results for running multiple times.

It should not be taken granted that always wrong results are produced. No, sometimes correct results are produced. It means that results will be unpredictable.

---

Misunderstanding on?

Thread skipped loop.!? No, thread didn't skip loop. Different threads accessed same value but before it could write it's own value other thread wrote the value and proceeded. As a result the next time it accessed the value, it picked up the wrong value.

This is known as Reader Writer Problem

---

Solution

In your program, t1 and t2 are accessing your count variable with different values. To prevent other threads from calling run() before other thread completes it we add a synchronized keyword before the method.

synchronized public void run(){}

The synchronized keyword guards the state from race conditions. Once, a thread enters the synchronized method, other threads are not allowed to use the method until the previous thread exits the method.

Here is the correct output due to synchronized keyword. Note: I used 200 as the end for loop.

---

Bonus

If there are proprietary methods you are using which take in shared data as input. You can use synchronized block

synchronized(objRef){
   //Method calling
}

objRef is the reference of the object being synchronized.

---

As recommended in comments
[Recommended Solution]

You should use AtomicInteger instead of native int. Use java.util.concurrent.atomic package.

Reference to java.util.concurrent.atomic

Instead of static int count = 0; use static AtomicInteger count = new AtomicInteger(0); and instead of count++; use count.incrementAndGet();

AtomicInteger is inherently synchronized.

Atomic Integer Reference Java Docs

---