如果直接从内存中读取易失性字段，那么从哪里读取非易失性字段？

Question

I was recently reading volatile fields are thread-safe because

When we use volatile keyword with a variable, all the threads read its value directly from the memory and don't cache it

So it got me to wonder, for non-volatile fields, where would the thread read its value from? I thought everything was stored in memory.

Answer 1

The statement you quote is a misconception. I recommend the following article: https://software.rajivprab.com/2018/04/29/myths-programmers-believe-about-cpu-caches/

if volatile variables were truly written/read from main-memory every single time, they would be horrendously slow – main-memory references are 200x slower than L1 cache references. In reality, volatile-reads (in Java) can often be just as cheap as a L1 cache reference, putting to rest the notion that volatile forces reads/writes all the way to main memory. If you've been avoiding the use of volatiles because of performance concerns, you might have been a victim of the above misconceptions.

Answer 2

Every thread has a Cache of the Main Memory.

A field may be declared volatile, in which case the Java Memory Model ensures that all threads see a consistent value for the variable

For Example we have this static counter that is not Thread Safe

static int counter = 0;

If two threads reads and write this variable it will be like this

Main memory  - > static int counter 
T1-> Cache of the Main Memory. Reads/Writes directly from Cache
T2-> Cache of the Main Memory. Reads/Writes directly from Cache 

So it will be inconsistent when reading and writing.

static volatile int counter = 0;

Main Memory - > static int counter;
T1 - > Read and Writes directly from the memory
T2 - > Read and Writes directly from the memory

I hope I give you a simple summary about this. Because you will need to check more about concurrency and Atomic Access for the concurrency of variables Check more in the Java Docs

Answer 3

Non volatile variables are usually stored in processor cache ( per thread ) and are only periodically updated in main memory.

The volatile modifier means that the variable data is stored in main memory every time it changes and hence is always up to date when another thread needs to access/edit it.