java - 多线程和 putIfAbsent 的竞争条件

Question

我在使用 putIfAbsent 时遇到问题，其中第二个线程将在第一个线程完成使用 pk 更新值之前尝试访问该值。

示例代码。

public <T> Object getLookupValue(final Class<T> type, String key, ConcurrentHashMap<String, T> concurrentMap) {
        try {

            T value = concurrentMap.get(key);

            if (value == null) {
                System.out.println("save");
                T t = type.getDeclaredConstructor(String.class).newInstance(key);
                Object returnedValue = concurrentMap.putIfAbsent(key, t);

                if (returnedValue == null) {
                    System.out.println("session save");
                    session.save(t);
                    System.out.println("t ouput " + t.toString());
                    return t;
                }
                return concurrentMap.get(key);
            } else {    
                System.out.println("update" + concurrentMap.get(name));
                return concurrentMap.get(key);
            }
        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException ex) {
            System.out.println("getLookupValue " + ex);
            Logger.getLogger(LineReaderParserImpl.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }

输出

key 2008 thread 1
save
session save
key 2008 thread 0
update Year{name =2008, pk =null}
year pk null thread 0
save
session save
t ouput Year{name =2008, pk =1}

有谁知道为什么线程 1 在线程 0 完成添加 pk 之前被调用，或者为什么线程 0 在生成 pk 之前添加对象？

Answer 1

来自ConcurrentHashMap API:

“但是，即使所有操作都是线程安全的，检索操作也不需要锁定，并且不支持以阻止所有访问的方式锁定整个表。”

在方法参数中声明 ConcurrentHashMap Final，并在同步块(synchronized block)中对其执行编辑。

public foo(final ConcurrentHashMap concurrentMap) {
    synchronized (concurrentMap) {
        //Your code here
    }
}

这将强制每个线程在修改并发Map 对象之前检索它的锁，这将解决您的竞争条件。

另外，如果需要多个线程同时访问 map ，但只需要在执行上述foo()方法中的应用程序代码时加锁，请为该方法创建一个锁获取，而不是使用 map 本身。

final Object fooLock = new Object();

public foo(final ConcurrentHashMap concurrentMap) {
    synchronized (fooLock) {
        //Your code here
    }
}

对第二个示例进行更多解释:

假设我有一个 ConcurrentHashMap，其键为 String，其值为 Year。不同的线程可以访问它以添加/删除值，并且我想对特定范围内的年份运行分析，同时不阻止我的程序在分析运行时添加/删除值。

如果锁定了 ConcurrentHashMap，其他线程将无法添加/删除值，直到锁定被删除。

在第二个示例中，我为要获取的方法创建了一个不同的锁，因此它不会锁定 map 本身。

ConcurrentHashMap<String, Year> concurrentMap;

final Object lock = new Object();

public void runAnalysis(final ConcurrentHashMap map) {
    /*synchronized (map) {
        //This will cause addValue() to lock up while the analysis is running
    }*/

    synchronized (lock) {
        //Now we can run a long-running analysis and not block the addValue() method

        //Additionally, if another thread calls runAnalysis(), it must wait to 
        //get our lock (when a current running analysis is completed) 
        //before it can start
    }

}

//This method needs access to concurrentMap, so we can't lock it
public void addValue() {
    concurrentMap.add("key", new Year());
}

假设这一切都是在 Analyzer 类中声明的。我还可以像这样声明 runAnalysis() 方法:

public synchronized void runAnalysis(ConcurrentHashMap map) {
    //Do analysis logic
}

此方法不会获取“锁”对象上的锁，而是获取 Analyzer 实例上的锁。一种稍微不同的方法，通常比创建自己的锁更常见。

请注意，如果我这样做，任何其他声明为“同步”的方法都将在 runAnalysis() 运行时被阻止，反之亦然。使用锁，您可以变得尽可能复杂，但如果您只需要同步一个类实例的一个方法，那么获取实例锁看起来比单独为该方法创建锁更干净.

您应该查找一些有关 Java 中的多线程、同步和锁的教程。