Basic principle of synchronized lock

Java Memory model review ：

1. Java All variables are stored in main memory
2. Each thread has its own working memory , It stores the copy of variables used by the thread （ This copy is a copy of this variable in main memory ）
3. All operations of a thread on shared variables must be in its own The working memory In the middle of , Can't read and write directly in main memory
4. Variables in the working memory of other threads cannot be accessed directly between different threads , The transfer of variable values between threads needs to be completed through main memory .
   Threads 1 Changes to shared variables , To be threaded 2 See in time , It has to go through the following 2 A process ：
   ① Put the working memory 1 The shared variables updated in are refreshed to main memory
   ② Update the value of the latest shared variable in main memory to working memory 2 in

Synchronized Synchronization lock ：

Synchronized The synchronization lock mainly guarantees the security of data by blocking Atomicity ;
It can also guarantee visibility ： When the thread is locked , Clear working memory first → Copy the latest variable in main memory to working memory → Finished executing the code → Refresh the value of the changed shared variable to main memory → Release the mutex .

principle ：

1. Every Java object It's all related to a monitor object , Add synchronized After and keyword monitor The object will take effect , By entering and exiting Monitor Objects implement mutual exclusion 、 sync ;
2. monitor Divided into Owner Indicates the owner of the monitor , At the same time, only one thread can become Owner ;
3. At first Monitor in Owner by null, When a thread t1 When accessing the object Owner It's empty , Will perform Monitor.Enter Instructions , The thread will occupy this object Owner;
4. When a thread t2 To access object discovery Owner It's locked , be t2 Will enter EntryList Waiting in line （ Blocked state ）, When t1 After execution, it will be executed Monitor.Exit command , The thread releases the Owner, notice EntryList Threads to compete Owner

Lock reentry ：
Execute multiple times on the same object Monitor.Enter-------- Lock reentry

In order to avoid lock reentry increasing overhead , It can make synchronized The locking granularity is larger , Less Monitor.Enter and Monitor.Exit The number of times

Be careful ：
1.synchronized( ) Objects of reference type should be placed inside , You can't put basic types ,
2. No addition synchronized Is not associated with the monitor