Two threads accessing an object and caching?

[David Moose]

public class Counter {

  private int count;

  public synchronized void increment() {
    count++;
  }
  public synchronized int getValue() {
    return count;
  }
  
}

If one thread frequently calls increment() and second thread frequently calls getValue(). Then what prevents the second thread from caching the count variable and thus returning an incorrect value?

[Prasad Saya]

What do you mean by 'cache'?

Here is some info on Java's threads in Java Language Specification's Chapter 17 (Threads and Locks, Synchronization and Memory Model): https://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html

[David Moose]

I mean by "cache" is that let's say second thread starts going first and executes the getValue a million times times and after that decides to not go to main memory but just get the value from CPU's register.

[Lakshman Arun]

Declare count as volatile

[Henry Wong]

David Moose wrote:I mean by "cache" is that let's say second thread starts going first and executes the getValue a million times times and after that decides to not go to main memory but just get the value from CPU's register.

Lakshman Arun wrote:Declare count as volatile

Not needed. The synchronization will prevent the accessing of the count variable at the same time. And crossing of the synchronization barrier will flush the processor cache (along with any register copies, which BTW, is not the same as the processor caches).

Having said that, keep in mind that the getValue() method returns a copy of the value. This means that when the method releases the lock, the copy can be different from the original variable.

Henry

[David Moose]

Henry Wong wrote:

David Moose wrote:I mean by "cache" is that let's say second thread starts going first and executes the getValue a million times times and after that decides to not go to main memory but just get the value from CPU's register.

Lakshman Arun wrote:Declare count as volatile

Not needed. The synchronization will prevent the accessing of the count variable at the same time. And crossing of the synchronization barrier will flush the processor cache (along with any register copies, which BTW, is not the same as the processor caches).

Having said that, keep in mind that the getValue() method returns a copy of the value. This means that when the method releases the lock, the copy can be different from the original variable.

Henry

Thanks!! So the act of locking in getValue() by second thread will synchronize memory/flush registers,L1,L2 etc Where one I find this in JLS https://docs.oracle.com/javase/specs/jls/se7/html/index.html

[Stephan van Hulst]

The JLS only explains this in terms of happens-before relationships. How these relationships are implemented is platform dependent, although the Java VM specification probably says something about it.

[David Moose]

I found this
https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/package-summary.html#MemoryVisibility