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
    }
}

这将强制每个线程在修改 concurrentMap Object 之前检索它，这将解决您的竞争条件。

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

final Object fooLock = new Object();

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

关于第二个例子的更多解释:

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

如果锁定 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 中的多线程、同步和锁的教程。