Introduction to the usage of synchronized keyword in Java (code example)

This article brings you an introduction to the usage of the synchronized keyword in Java (code examples). It has certain reference value. Friends in need can For reference, I hope it will be helpful to you.

In concurrent programming, the synchronized keyword is a common role. We used to call the synchronized keyword weight lock, but synchronized was optimized in JDK1.6 and biased locks and lightweight locks were introduced. This article introduces how to use the synchronized keyword, the differences and implementation principles of bias locks, lightweight locks and heavy locks.

Let’s first look at the 4 uses of the synchronized keyword.

1. Modify ordinary methods

private synchronized void synMethod(){
}

In this usage, Object instance of synchronized lock.

2. Modify the static method

private static synchronized void synMethod(){
}

synchronized In this case, the lock is the current Class object.

3. Synchronous method block

private  void synMethod1(){
        synchronized(this){
            
        }
    }    
    private  void synMethod2(){
        synchronized(ThreadTest.class){
            
        }
    }

lock object instance in synMethod1; synMethod2 Is the current Class object.

Introducing the lock principle again

Before introducing the lock principle, let’s first get to know the Java object header Mark Word, taking 32-bit as an example.

The above table describes the information stored in the object header when the object is in each lock state.

1. Biased lock

#In the actual environment, when a thread accesses a synchronized block, if no other thread competes for the lock, and The same thread acquires the lock multiple times, that is, a single thread runs synchronization code. In this case, if the thread is blocked every time, it means a waste of CPU performance. In this case, the concept of biased locking is introduced.

• ##Accessing synchronized code blocks

• Determine whether the thread ID stored in the object header Mark Word points to the current thread. If so, it indicates that the current lock is reentrant. There is no need to obtain the lock and directly execute the synchronization code

• If not, try to use the CAS algorithm to update the thread ID to the object header.

• #Successfully, obtain the lock and execute the synchronization code. Failure to update indicates that there is lock competition. Wait for the global safe point, suspend the thread that owns the biased lock, and choose to upgrade the biased lock to a lightweight lock or set it to no lock according to the lock flag in the object header.

You can use -XX:-userBiasedLocking=false to turn off JVM biased lock optimization, and enter lightweight locking directly by default.

2. Lightweight lock

• Access synchronization code block, first create a lock record (Lock Record) area in the thread stack of the current thread.

• Copy the object header Mark Word to the Lock Record.

• Use CAS to try to update the thread pointer in the object header Mark Word to a pointer to the current thread

• If the update is successful, you will get a lightweight Lock.

• Update failed, check whether the pointer in Mark Word points to the current thread.

• If yes, it means that the lock is reentrant. Execute the synchronized code block

• If not, it means there is competition at this time. Lightweight locks need to be expanded into weight locks.

The above is the detailed content of Introduction to the usage of synchronized keyword in Java (code example). For more information, please follow other related articles on the PHP Chinese website!