How to achieve thread safety in synchronized blocks of Java functions?

The synchronized block of Java functions achieves thread safety by acquiring synchronization locks. When a thread enters the synchronized block, other threads cannot enter, ensuring that access to shared data is thread safe. Specific steps: Declare a synchronized method or code block and use the synchronized keyword. When a thread enters a synchronized block, it acquires a synchronization lock. Other threads cannot access the data in the synchronized block until the first thread releases the synchronization lock. A synchronized block contains only the code that needs to be synchronized.

#How to achieve thread safety in synchronized blocks of Java functions?

Synchronized blocks are syntactic sugar used to make non-thread-safe functions thread-safe in a multi-threaded environment. It is essentially a mutex lock, when a thread enters a synchronized block, it acquires the synchronized lock, and no other thread can enter the synchronized block until that thread releases the lock.

Syntax

public synchronized void myFunc() {
    // 临界区代码
}

Practical case

Suppose we have a non-thread-safe functionincrement(), it adds 1 to a counter value. If multiple threads call this function at the same time, the counter value may be incorrect. We can use synchronized blocks to solve this problem:

private int counter;

public synchronized void increment() {
    counter++;
}

In this way, when a thread calls the increment() function, it will acquire an exclusive lock on counter. No other thread can access counter until the first thread releases the lock, ensuring that access to counter is thread-safe.

It should be noted that:

• Only the synchronized keyword can be used to synchronize methods or code blocks, not classes.
• Synchronized blocks are only valid within the code block. Once the thread leaves the synchronized block, other threads can enter.
• Do not nest synchronized blocks within synchronized blocks, this may cause deadlock.
• Try to keep synchronization blocks as small as possible, covering only the code that needs to be synchronized.

The above is the detailed content of How to achieve thread safety in synchronized blocks of Java functions?. For more information, please follow other related articles on the PHP Chinese website!