如何处理 java 框架中函数式编程的并发问题？

// 使用互斥锁来保护共享变量
final Object lock = new Object();

public void updateValue(int value) {
    synchronized (lock) {
        this.value = value;
    }
}

// 使用读写锁实现并发读写
final ReadWriteLock lock = new ReentrantReadWriteLock();

public int getValue() {
    lock.readLock().lock();
    try {
        return this.value;
    } finally {
        lock.readLock().unlock();
    }
}

public void updateValue(int value) {
    lock.writeLock().lock();
    try {
        this.value = value;
    } finally {
        lock.writeLock().unlock();
    }
}

// 使用 Kotlin Coroutines 并发执行任务
runBlocking {
    val coroutine1 = launch { ... }
    val coroutine2 = launch { ... }
    coroutine1.join()
    coroutine2.join()
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;

public class ConcurrentCache<K, V> {

    private final ConcurrentHashMap<K, V> cache = new ConcurrentHashMap<>();
    private final ReentrantLock lock = new ReentrantLock();

    public V get(K key) {
        V value = cache.get(key);
        if (value == null) {
            lock.lock();
            try {
                value = computeValue(key);
                cache.put(key, value);
            } finally {
                lock.unlock();
            }
        }
        return value;
    }

    private V computeValue(K key) { ... }
}