Volatile and threads

volatile keyword

If a variable is in more than one CPU There are caches in （ It usually appears in multithreaded programming ）, Then there may be cache inconsistency . To solve cache inconsistency , Generally speaking, there are the following 2 A solution ：

1. By adding... On the bus LOCK# The way of locking

2. Through cache consistency protocol

this 2 All of them are provided at the hardware level .

i If in the process of executing this code , Issued on the bus LCOK# Lock signal , Then wait until the code is completely executed , other CPU From variables i Where the memory reads variables , Then carry out the corresponding operation . This solves the problem of cache inconsistency .

Cache consistency protocol . The most famous is Intel Of MESI agreement ,MESI The protocol ensures that the copies of shared variables used in each cache are consistent . Its core idea is ： When CPU When writing data , If the variable of the operation is found to be a shared variable , In other CPU A copy of the variable also exists in , Signal others CPU Set the cache row of this variable to invalid state , So when other CPU When you need to read this variable , It is found that the cache row of this variable in its own cache is invalid , So it's going to re read from memory .

Java Inter memory interaction

JLS The operation instruction of thread to main memory is defined ：lock,unlock,read,load,use,assign,store,write. These behaviors are indecomposable atomic operations , Interdependence in use ,read-load Copy variables from main memory to current working memory ,use-assign Execute the code to change the value of the shared variable ,store-write Refresh main memory with working memory data .

• read（ Read ）： Operates on the main memory variable , Transfers a variable value from main memory to the thread's working memory , For subsequent load The action to use

• load（ load ）： A variable acting on working memory , It is the read The operation places the values of the variables obtained from main memory into a copy of the variables in working memory .

• use（ Use ）： A variable acting on working memory , Passes the value of a variable in working memory to the execution engine , This is done whenever the vm gets a bytecode instruction that requires the value of the variable to be used .

• assign（ assignment ）： A variable acting on working memory , It assigns a value received from the execution engine to a variable in the working memory , This is done whenever the vm receives a bytecode instruction that assigns a value to a variable .

• store（ Storage ）： A variable acting on working memory , Transfers the value of a variable in working memory to main memory , For subsequent write The operation of .

• write（ write in ）： A variable acting on main memory , It is the store Operations are passed from the value of a variable in working memory to the variable in main memory .

Atomicity , visibility , Orderliness

Three features of multithreading .

　　 For visibility ,Java Provides volatile Keywords to ensure visibility .
　　 When a shared variable is volatile When decorating , It ensures that the modified value is immediately updated to main memory , When there are other threads that need to read , It will go to memory to read new values .
　　 And common shared variables don't guarantee visibility , Because after the common shared variable is modified , When it is written to main memory is uncertain , When other threads go to read , At this time, the memory may still be the old value , So there's no guarantee of visibility .

in addition , adopt synchronized and Lock It also ensures visibility ,synchronized and Lock It can guarantee that only one thread can acquire lock and execute synchronization code at the same time , And before releasing the lock, the changes to variables will be refreshed to main memory . So you can guarantee visibility .

The following passage is from 《 In depth understanding of Java virtual machine 》：
“ Observe the addition of volatile Keywords and did not add volatile Keyword generated assembly code found , Join in volatile When a keyword , One more lock Prefix instruction ”
　　　
lock The prefix instruction is actually equivalent to a Memory barrier （ It's also a memory fence ）, The memory barrier will provide 3 Features ：

1. It ensures that instructions are reordered without putting the instructions behind them in front of the memory barrier , It doesn't put the previous instructions behind the memory barrier ; That is, when the instruction of memory barrier is executed , All the operations before it have been completed ;

2. It forces changes to the cache to be written to main memory immediately ;

3. If it's a write operation , It can lead to other CPU The corresponding cache row in is invalid .

Here are a few Java Use in volatile Several scenes of .

• State marker quantity

• double check Prevent instruction reordering :
  Prevent instruction reordering from causing other threads to get uninitialized objects .instance = new Singleton() This sentence , This is not an atomic operation , In fact JVM I've probably done the following 3 thing .

  But in JVM There are instructions reordering optimizations in the immediate compiler of . That is to say, the order of the second and third steps above is not guaranteed , The final order of execution may be 1-2-3 It could be 1-3-2. If it's the latter , It's in 3 completion of enforcement 、2 Before execution , By thread two , At this time instance Right and wrong null 了 （ But it's not initialized ）, So thread two will directly return instance, And then use , Then an error . added volatile No reordering .

  • to instance Allocate memory

  • call Singleton To initialize member variables

  • take instance Object points to the allocated memory space （ Finish this step instance It's just wrong null 了 ）

When new When an object , It is also allocated in main memory .

synchronized Key words and volatile The difference between keywords

• volatile Keyword is a lightweight implementation of thread synchronization , therefore volatile Performance is definitely better than synchronized Keywords are better . however volatile Keywords can only be used for variables , and synchronized Keywords can modify methods and code blocks .

• Multithreaded access volatile Keywords don't block , and synchronized Keywords may block .

• volatile Keywords ensure data visibility , But it doesn't guarantee the atomicity of the data .synchronized Keywords both guarantee .

• volatile Keyword is mainly used to solve the visibility of variables among multiple threads , and synchronized Keyword solves the synchronization of accessing resources among multiple threads

Remember to point 「 Fabulous 」 and 「 Looking at 」↓

Love you