Synchronized keyword details

Preface

Thread safety is an important concern in concurrent programming , It should be noted that , There are two main causes of thread safety problems ：

• One is the existence of shared data ( Also called critical resources )
• Second, there are multiple threads operating on shared data

So in order to solve this problem , We may need such a plan , When there are multiple threads operating on shared data , It is necessary to ensure that there is only one thread sharing data at the same time , Other threads must wait until the thread finishes processing the data , This approach has a noble name called mutex , That is to say, the lock that can achieve the purpose of exclusive access , That is to say, when a shared data is added with a mutually exclusive lock by the thread currently being accessed , At the same time , Other threads can only wait , Until the current thread finishes processing and releases the lock .

stay Java in , keyword synchronized Can guarantee at the same time , Only one thread can execute a method or a block of code ( It mainly refers to the operation of shared data in methods or code blocks ), At the same time, we should also pay attention to synchronized Another important role ,synchronized It can guarantee the change of a thread ( It's mainly about changes in shared data ) Seen by other threads （ Guaranteed visibility , Completely replaceable Volatile function ）, This is really important .

Synchronized Use

• A lock can only be acquired by one thread at a time , A thread that does not acquire a lock can only wait ;

• Each instance should have its own lock (this), The different instances are independent of each other ; exception ： The lock object is *.class as well as synchronized Modification is static Method time , All objects share the same lock

• synchronized The method of decoration , Whether the method finishes executing normally or throws an exception , Both release locks

Object lock

Including method locks ( The default lock object is this, Current instance object ) And synchronization code block lock ( Specify the lock object by yourself )

• Code block form ： Manually specify locked objects , It's also this, It can also be a custom lock

• Method lock form ：synchronized Decorate common methods , The lock object defaults to this

Kind of lock

finger synchronize Modifies a static method or specifies that the lock object is Class object

• synchronize Modified static method

• synchronized Specifies that the lock object is Class object

In depth understanding of Synchronized

Use Synchronized What should we pay attention to

• The lock object cannot be empty , Because the lock information is stored in the object header

• Do not oversize , Affect the speed of program execution , Too much control , Writing code is also error prone

• Avoid deadlock

• If you can choose , Don't use Lock Don't use synchronized keyword , use java.util.concurrent All kinds of classes in the bag

synchronized Is it a fair lock

synchronized It's actually unfair , It is possible for the new thread to get the monitor immediately , The thread that has been waiting for a long time in the waiting area may wait again , This is good for improving performance , But it can also lead to hunger .

Synchronized The defects of

• Low efficiency ： Less lock release , The lock will not be released until the code is executed or abnormally terminated ;

• You cannot set a timeout when trying to acquire a lock , You cannot interrupt a thread that is using a lock , Relatively speaking ,Lock You can interrupt and set timeout ;

• inflexible ： Lock and release at a single time , Each lock has only one single condition ( An object ), Relatively speaking , Read and write locks are more flexible

• There is no way to know if the lock was successfully acquired , Relatively speaking ,Lock You can get the status

Lock Solve the corresponding problems

Lock Class is not explained too much here , It mainly depends on the inside 4 A way :

• lock(): Lock

• unlock(): Unlock

• tryLock(): Attempt to acquire lock , Return to one boolean value

• tryLock(long,TimeUtil): Attempt to acquire lock , Timeout can be set Synchronized Only locks are associated with one condition ( Get lock or not ) Related to , inflexible , later Condition And Lock The combination of solves this problem .

When multiple threads compete for a lock , The remaining threads that don't get locks can only keep trying to get locks , Without interrupting . High concurrency leads to performance degradation .ReentrantLock Of lockInterruptibly() Method can give priority to responding to interrupts . A thread waits too long , It can interrupt itself , then ReentrantLock Respond to this interrupt , No longer let this thread wait . With this mechanism , Use ReentrantLock It won't be like synchronized That creates a deadlock .

ReentrantLock Is a common class , It is a reentrant mutex Lock, It has with use synchronized Methods have the same basic behavior and semantics as implicit monitor locks accessed by statements , But it's more powerful .

Use @guardedby Synchronize annotations

• @GuardedBy( "this" ) Protected by the internal lock of the object

• @GuardedBy( "fieldName" ) Receive and fieldName Reference the associated lock protection

• @GuardedBy( "ClassName.fieldName" ) Subject to the static of a class field The lock is saved

• @GuardedBy( "methodName()" ) The lock object is methodName() Return value of method , Protected by this lock

• @GuardedBy( "ClassName.class" ) suffer ClassName Direct lock object protection of class , Instead of the lock object of an instance of this class