java - 一个同步块(synchronized block)与多个 AtomicInteger 增量相比

Question

我知道最好使用 AtomicInteger而不是 synchronized block 以增加共享的 int 值。但是，它在多个 int 值的情况下是否仍然成立？

以下哪种方法更好，为什么？有没有更好的方法来提高性能？

1)使用同步块(synchronized block):

int i, j, k, l;
public void synchronized incrementValues() {
    i++;j++;k++;l++;
}

2) 使用 AtomicInteger:

AtomicInteger i,j,k,l;
// Initialize i, j, k, l

public void incrementValues() {
    i.incrementAndGet();
    j.incrementAndGet();
    k.incrementAndGet();
    l.incrementAndGet();
}

或者如果我使用 ReentrantLock 会更快吗？ ？

3) 使用 ReentrantLock :

ReentrantLock lock = new ReentrantLock()
int i, j, k, l;
public void incrementValues() {
    lock.lock();
    try {
        i++;j++;k++;l++;
    } finally {
        lock.unlock();
    }
}

这是我的问题:

1. 3 是他们中最快的吗？
2. 2 呢？对于单个整数，2 比 1 快。如果整数的数量增加，2 会变得比 1 慢吗？

编辑 1根据 Matthias 的回答修改了问题。

i,j,k,l 相互独立。单个增量应该是原子的，而不是整体的。如果线程 2 在线程 1 修改 k 之前修改 i 是可以的。

编辑 2基于目前评论的附加信息

我不是在寻找确切的答案，因为我知道这将取决于功能的使用方式和争用量等，并且针对每个用例进行测量是确定确切答案的最佳方法。但是，我希望看到人们分享他们的知识/文章等，这将阐明影响情况的参数/优化。感谢@Marco13 的文章。它提供了很多信息。

Answer 1

首先，#2 不是线程安全的。 incrementAndGet() 是原子的，但是，连续调用四个 incrementAndGet 操作不是。 (例如，在第二个 incrementAndGet 之后，另一个线程可以进入相同的方法并开始执行与下面的示例相同的操作。

T1: i.incrementAndGet();
T1: j.incrementAndGet();
T1: k.incrementAndGet();
T2: i.incrementAndGet();
T2: j.incrementAndGet();
T1: l.incrementAndGet();
T2: k.incrementAndGet();
T2: l.incrementAndGet();

然后，如果它介于 #1 和 #3 之间:如果您不喜欢高速股票交易，那么这对您来说无关紧要。可能会有非常小的差异(在整数的情况下可能以纳秒为单位)，但这并不重要。但是，我总是选择 #1，因为它更简单，使用起来也更安全(例如，假设您忘记将 unlock() 放在 finally block 中 - 那么您可能会遇到大麻烦)

关于您的修改:对于数字 1:有时一次原子地修改多个值可能很重要。考虑数据不仅递增而且同时读取。您会假设在任何时间点所有变量的值都非常相同。但是，由于读取数据时更新操作不是原子的，因此可能是 I=j=k=5 和 l=4，因为执行增量的线程尚未到达最后一个操作。这是否是一个问题在很大程度上取决于您的问题。如果您不需要这样的保证，请不要在意。

对于数字 2:优化难，并发更难。我只能建议不要考虑这种微优化。在最好的情况下，这些优化可以节省纳秒级，但会使代码变得非常复杂。在最坏的情况下，优化中存在错误假设或逻辑错误，您最终会遇到并发问题。然而，您的优化很可能会表现更差。还要考虑到您编写的代码可能需要在以后的某个时间点由其他人维护。在编程执行中节省毫秒的地方，你浪费了处理器生命的数小时，处理器试图理解你想做什么以及为什么你这样做，同时试图修复那个讨厌的多线程错误。所以为了方便起见:synchronized 是最好用的东西。

kiss 原则真的适用于并发。