See how much volatile you know

For the sake of running speed ,java The compiler will put frequently accessed variables into the cache （ Strictly speaking, it should be working memory ） in , Read variables are read from the cache . But in multithreaded programming , There may be inconsistencies between the values in memory and the values in the cache .volatile Used to limit that variables can only be read from memory , Ensure that for all threads , The values are consistent . however volatile Atomicity is not guaranteed , You can't guarantee thread safety

volatile Keyword pair any single volatile The reading and writing of variables can ensure atomicity , But similar to volatile++ This kind of compound operation cannot guarantee atomicity . If you need to guarantee atomicity for this composite operation , It is best to synchronized keyword . namely synchronized Guarantee three characteristics , Atomicity , Orderliness , visibility ,volatile To ensure order , visibility , Atomicity is not guaranteed .

---

in general ： volatile The characteristics of are

Orderliness , visibility
however

newly added

Once a shared variable （ Member variables of class 、 Static member variable of class ） By volatile After retouching , So there are two levels of semantics ：1） It ensures the visibility of different threads when they operate on this variable , That is, a thread changes the value of a variable , This new value is immediately visible to other threads .

2） Disables instruction reordering .

volatile Only guarantees are provided when accessing the variable , Every time I read the latest value from memory , Registers are not used to cache this value —— Read from memory every time .

And the modification of this variable ,volatile There is no guarantee of atomicity .

Due to timely updates , It is likely to cause another thread to access the latest variable value , Unable to jump out of the loop

Under multithreading, the counter must be protected by lock