Java Concurrency, synchronization. I increment two variables in one Method, but they are different

Now I'm learning Java concurrency, and I've tried to write some example with threads that uses same resources.

In my idea, I wanted to write some data class, that contains two numbers and I wanted to create two threads. One thread is constantly increment two numbers in one method, and another thread writes the values of numbers.

Code is below.

package org.study.java.concurrency;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;
class SomeDataClass  {
private final AtomicLong number1;
private final AtomicLong number2;
public SomeDataClass(Long number1, Long number2) {
this.number1 = new AtomicLong(number1);
this.number2 = new AtomicLong(number2);
}
public synchronized void NextStep() {
synchronized (this) {
this.setNumber1(getNumber1() + 1);
this.setNumber2(getNumber2() + 1);
}
Thread.yield();
}
public synchronized Long getNumber1() {
return number1.get();
}
public synchronized Long getNumber2() {
return number2.get();
}
public synchronized void setNumber1(Long number1) {
this.number1.set(number1);
}
public synchronized void setNumber2(Long number2) {
this.number2.set(number2);
}
}
class ProcessRunner implements Runnable {
private final SomeDataClass dataClass;
public ProcessRunner(SomeDataClass dataClass) {
this.dataClass = dataClass;
System.out.println("CameDataClass to ProcessRunner = " + dataClass);
System.out.println("With values, number1 = " + dataClass.getNumber1() + ", number2 = " + dataClass.getNumber2());
}
@Override
public void run() {
while (true) {
dataClass.NextStep();
}
}
}
class ProcessChecker implements Runnable {
private final SomeDataClass dataClass;
public ProcessChecker(SomeDataClass dataClass) {
this.dataClass = dataClass;
System.out.println("Came dataclass to process checker = " + dataClass);
System.out.println("With values, number1 = " + dataClass.getNumber1() + ", number2 = " + dataClass.getNumber2());
}
@Override
public void run() {
try {
while (true) {
System.out.println("DataClass = " + dataClass + ",  CurrentNumber1 = " + dataClass.getNumber1() + ", CurrentNumber2 = " + dataClass.getNumber2());
TimeUnit.SECONDS.sleep(2);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class ConcurrencyExample {
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
SomeDataClass dataClass = new SomeDataClass(1L, 1L);
executorService.submit(new ProcessRunner(dataClass));
executorService.submit(new ProcessChecker(dataClass));
executorService.shutdown();
}
}

The result of this code is

And the result is like
CameDataClass to ProcessRunner = org.study.java.concurrency.SomeDataClass@266474c2
With values, number1 = 1, number2 = 1
Came dataclass to process checker = org.study.java.concurrency.SomeDataClass@266474c2
With values, number1 = 177, number2 = 180
DataClass = org.study.java.concurrency.SomeDataClass@266474c2, CurrentNumber1 = 1024, CurrentNumber2 = 1026
DataClass = org.study.java.concurrency.SomeDataClass@266474c2, CurrentNumber1 = 2787500, CurrentNumber2 = 2787531
DataClass = org.study.java.concurrency.SomeDataClass@266474c2, CurrentNumber1 = 5828168, CurrentNumber2 = 5828509
DataClass = org.study.java.concurrency.SomeDataClass@266474c2, CurrentNumber1 = 8834895, CurrentNumber2 = 8837607
Process finished with exit code 130 (interrupted by signal 2: SIGINT)
Look, the CurrentNumber1 and CurrentNumber2 is different, but I expected that they would be the same.

Look, the CurrentNumber1 and CurrentNumber2 is different, but I expected that they would be the same.

The problem is that the numbers are different. I don't understand why they are different and what I should change in code to make them equal?

System.out.println("DataClass = " + dataClass + ",  CurrentNumber1 = " + dataClass.getNumber1() + ", CurrentNumber2 = " + dataClass.getNumber2());

You are calling dataClass.getNumber1() and dataClass.getNumber2() as part of println. But there is no guarantee both calls will be made one after another. What is happening in this case is the updater thread is updating values between these two calls.

1. getNumber1()
2. ..ProcessRunner runs many times...
3. getNumber2()

Synchronizing on the dataClass object will produce the same value for number1 and number2 as the entire print statement will be executing atomically.

synchronized (dataClass) {
System.out.println("DataClass = " + dataClass + ",  CurrentNumber1 = " + dataClass.getNumber1() + ", CurrentNumber2 = " + dataClass.getNumber2());
}

Or, add a method to print the values in the SomeDataClass class and call it from the ProcessChecker.

public synchronized void printNumbers() {
System.out.println("CurrentNumber1 = " + getNumber1() + ", CurrentNumber2 = " + getNumber2());
}