Synchronized lock

Usage mode ：

• Method lock ： The lock object is the caller itself .
• Code block lock ： Lock object for synchronized（Object o） Incoming objects .

Realization principle ：

       synchronized yes JVM Built in lock , be based on Monitor Mechanism realization , Mutex primitives that depend on the underlying operating system Mutex（ The mutex ）, It's a heavyweight lock , Low performance . Of course ,JVM Built in lock in 1.5 Later versions made significant Optimize , Such as lock coarsening （Lock Coarsening）、 Lock elimination （Lock Elimination）、 Lightweight lock （Lightweight Locking）、 Biased locking （Biased Locking）、 Adaptive spin （Adaptive Spinning） And other technologies to reduce lock operation Cost of work , The concurrency performance of built-in locks is basically the same as Lock flat .

       Java The virtual machine supports the synchronization of the method and the instruction sequence in the method through a synchronization structure ：monitor. The synchronization method is through access_flags Set in ACC_SYNCHRONIZED Logo to achieve ; Synchronization code block is through monitorenter and monitorexit To achieve . The execution of the two instructions is JVM By calling the mutual exclusion of the operating system The original language mutex To achieve , Blocked threads will be suspended 、 Waiting for rescheduling , It can lead to “ User mode and kernel mode ” Two states Switch back and forth between , It has a great impact on the performance . Either way , The essence is to get the monitor of an object , Only one thread can get synchronized Protect the monitor of the object .

Monitor（ Tube side / The monitor ）

      Monitor, Literal translation “ The monitor ”, The field of operating system is generally translated as “ Tube side ”. Management refers to the process of managing and operating shared variables , Let them support concurrency . stay Java 1.5 Before ,Java The only concurrent language provided by language is management ,Java 1.5 Later provided SDK The contract is also based on the management process . except Java outside ,C/C++、C# And other high-level languages also support management .synchronized Key words and wait()、notify()、notifyAll() These three methods are Java Part of realizing tube side technology in .

Mark Structure

  characteristic ：

    The lock flag bits of non lock state and biased lock state are 01, All fields that are biased to lock are distinguished .

    The deflection lock has no place to store hashcode, Lightweight lock hashcode Stored in the recorded stack frame , Heavyweight locks will be in Monitor It's recorded in hashCode.

Synchronized Four states

• No lock state ： The lock is created to handle the state that is not acquired by any thread . Of the newly created object Mark Word Medium Thread Id by 0, That at this time In a biased but not biased to any thread , It's also called Anonymous bias state (anonymously biased).
• Biased locking ： When the lock is acquired by the thread for the first time, it enters the biased lock mode . In the process of acquiring the lock , Threads pass through CAS operation , In the lock object markword Record the biased lock state and the thread of the current thread ID, When the thread requests the lock again , Just check the lock object markword Whether the lock mark of is a thread that biases locks and records ID Is it the current thread's ID, There is no need to do anything about applying for a lock , even CAS No need , So the performance is high . Biased locking uses a mechanism that waits until there is competition to release the lock , So when other threads try to compete for biased locks , The thread holding the biased lock will release the lock . When the deflection lock is released , The thread holding the biased lock will be run to a safe point , Then check whether the thread survives and whether it needs to continue holding the biased lock , If the thread survives or needs to continue holding the biased lock , The preference lock is upgraded to lightweight lock . If the thread does not survive or does not need to continue to hold the biased lock , Then the lock state will be reset to the unlocked state , And then through CAS Operations are biased towards new threads . Bias locked in jdk1.6 After the default on , Can pass jvm Parameter to close the bias lock ：-XX:-UseBiasedLocking = false.

// Closing delay opening bias lock  
‐XX:BiasedLockingStartupDelay=0 
// Do not bias the lock  
‐XX:‐UseBiasedLocking 
// Enable bias lock  
-XX:+UseBiasedLocking

• Lightweight lock ： When a thread acquires a lightweight lock, it will create a space in the stack frame for storing lock records (Lock Record), Then lock the markword Copy to this space , be called Displaced MarkWord( be homeless markword). After use CAS The mechanism keeps trying to lock the middle of the object's header markword Replace with a pointer to the lock record in the current stack frame , And the current stack frame owner The pointer changes to the lock object header MarkWord The pointer . If this operation succeeds , Then the current thread obtains a lightweight lock . If it doesn't work , Then the lock is upgraded to a heavyweight lock .
  That is, the scenario for lightweight locks is where threads alternately execute synchronous blocks , If there are occasions where multiple threads access the same lock at the same time , It will cause the lightweight lock to expand to heavy Magnitude lock .
• Heavyweight lock ： Except for the thread that owns the lock , Other threads block . For the pursuit of throughput , A scenario where a synchronization block or synchronization method takes a long time to execute .

The calling object of partial lock revocation HashCode

Calling the obj.hashCode() or System.identityHashCode(obj) Method will cause the biased lock of the object Revoked . Because for an object , Its HashCode It will only be generated once and saved , Bias locks have no place to save hashcode Of .

• Lightweight locks will be recorded in the lock record hashCode
• Heavyweight locks will be in Monitor It's recorded in hashCode

When the object is in a deflectable state （ So threads ID by 0） And in a biased state , call HashCode Calculation will make the object no longer Unable to bias ：

• When the object can be biased ,MarkWord Will become unlocked , And can only be upgraded to a lightweight lock ;
• When the object is in a bias lock , call HashCode The deflection lock will be forcibly upgraded to a weight lock .

Call of partial lock revocation wait/notify

Bias lock state execution obj.notify() Will upgrade to lightweight lock , call obj.wait(timeout) Will be upgraded to heavyweight locks

      Let's say I have two threads , A The first thing to get is the deflection lock , that B Spin waiting lock acquisition will occur . When B When the spin acquires the lock , Will check the A Is it still alive , If you don't , Then the lock is reset to the unlocked state , here B Compete to lock , Set it to bias lock . If you survive , Then the lock is upgraded to a lightweight lock . When B When the spin fails and the lock is not obtained , The lock is automatically upgraded to a heavyweight lock , All threads will not spin when competing for heavyweight locks . And in the future competition , This lock will only be in the state of heavyweight lock . Unless GC, Recycle the lock as garbage . The second scenario , If there is N Threads compete for locks at the same time , Only one spin failed to acquire the lock , Then the lock will also be upgraded to a heavyweight lock .