How does the read-write lock mechanism in Java functions achieve thread safety?

The read-write lock mechanism allows multiple threads to read data at the same time, but only allows one thread to write data. In Java, you can use the ReentrantReadWriteLock class to implement a read-write lock: Read lock: Allows multiple threads to obtain read access at the same time without blocking write operations. Write Lock: Gain exclusive write access, blocking all other read/write operations.

Read-write lock mechanism in Java functions: A guide to achieving thread safety

Read-write lock is a concurrency control mechanism , allowing multiple threads to read and write data simultaneously while preventing damage to data integrity. In Java, read-write locks can be implemented using the ReentrantReadWriteLock class in the java.util.concurrent.locks package.

Concept

• Read lock: Allows multiple threads to obtain read access at the same time without blocking write operations.
• Write lock: Gain exclusive write access, blocking all other read/write operations.

Implementation

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ThreadSafeFunction {

    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public int calculate(int x, int y) {
        lock.readLock().lock();
        try {
            // 读操作
            return x + y;
        } finally {
            lock.readLock().unlock();
        }
    }

    public void update(int x, int y) {
        lock.writeLock().lock();
        try {
            // 写操作
            // 更新数据
        } finally {
            lock.writeLock().unlock();
        }
    }
}

Practical case

Consider a shared counter, multiple threads may read and write at the same time :

public class SharedCounter {

    private int count;
    private final ThreadSafeFunction function;

    public SharedCounter() {
        function = new ThreadSafeFunction();
    }

    public int getCount() {
        return function.calculate(count, 0);
    }

    public void increment() {
        function.update(count, count + 1);
    }
}

In a multi-threaded environment, different threads can acquire the read lock or write lock of the counter at the same time, thereby ensuring data integrity and avoiding data competition.

The above is the detailed content of How does the read-write lock mechanism in Java functions achieve thread safety?. For more information, please follow other related articles on the PHP Chinese website!