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

Java functions achieve thread safety through synchronization methods. Synchronized methods use the synchronized keyword. When a thread calls a synchronized method, it must first acquire the lock of the object to which the method belongs before executing the method body. Other threads trying to call the same method will be blocked until the first thread releases the lock.

How to achieve thread safety in the synchronization method of Java function

In a multi-threaded environment, in order to ensure the consistency and integrity of data , shared resources need to be synchronized. The purpose of synchronization is to ensure that only one thread can access shared resources at the same time. Java provides synchronization methods to implement this feature.

Synchronized methods

Methods in Java can be declared as synchronized methods using the synchronized keyword. When a synchronized method is called, the thread must first acquire the lock of the object to which the method belongs before it can execute the method body. If another thread attempts to call the same synchronized method, it will be blocked until the first thread releases the lock.

Example

The following is an example that demonstrates how to use synchronous methods to protect shared resources:

public class Counter {
    private int count = 0;

    // 同步方法
    public synchronized void increment() {
        count++;
    }
}

increment() The method is declared as synchronized method, which means that only one thread can execute this method at the same time.

Practical Case

The following code shows a practical case in which a synchronization method is used to protect shared resources:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ConcurrentCounterDemo {

    public static void main(String[] args) throws InterruptedException {
        // 创建一个共享资源
        Counter counter = new Counter();

        // 创建一个线程池
        ExecutorService executor = Executors.newFixedThreadPool(10);

        // 提交任务到线程池
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> counter.increment());
        }

        // 等待所有任务完成
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);

        // 打印计数
        System.out.println("最终计数：" + counter.count);
    }
}

In this example , the increment() method is used to concurrently increment the shared count variable. If synchronization methods are not used, different threads may modify the count variable at the same time, causing the final count to be incorrect. By using the synchronization method, we can ensure that only one thread can access the count variable at the same time, thereby ensuring data consistency and integrity.

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