CODEWITHSUNDEEP
javamultithreading
Rudziankoŭ
Rudziankoŭ

Reputation: 11251

Does jvm guarantie update of processor cache after switching threads?

I was asked by interviewer is there any danger not to use volatile if we know for sure that threads will never interfere.

eg. we have:

int i = 10; 
// Thread 1 
i++; 
// await some time and switch to Thread 2
getI();

I don't use any synchronization.
Do we have any danger to receive outdated value of i by second thread?

Upvotes: 1

Views: 65

Answers (3)

Solomon Slow
Solomon Slow

Reputation: 27125

If an interviewer asked me that question, I would answer in terms of the Java Language Specification. There is no "cache" or "main memory" in the JLS. The JLS talks about fields (a.k.a., instance variables and class variables) and it makes very specific guarantees about when an update to a field that happens in thread A will become visible in thread B. Implementation details like "cache" and "memory barriers" and can vary from one platform to another, but a program that is correct with respect to the JLS should (in theory) be correct on any Java platform.

Upvotes: 1

Slomo
Slomo

Reputation: 1234

You might receive outdated values, yes.

The reason in short is:

Every thread in Java has its own little 'cache'. For performance reasons, threads keep a copy of the 'master' data in their own memory. So you basically have a main memory and a threadlocal one. The volatile keyword forces the thread to access the main memory and not its local one.

Refer to this for more information: http://www.ibm.com/developerworks/library/j-5things15/

Upvotes: 1

Peter Lawrey
Peter Lawrey

Reputation: 533530

Without volatile or synchronized or read/write barrier, there is no guarantee that another thread will ever see a change you made, no matter how long your wait. In particular boolean fields can be inlined into the code and no read actually performed. In theory, int values could be inlined if the JVM detects the field is not changed by the thread (I don't believe it actually does though)

we know for sure that threads will never interfere.

This is not something you can know, unless the reading thread is not running when you perform the update. When thread starts it will see any changes which occurred before it started.

Upvotes: 4

Related Questions