java中的易失或同步

Question

我们有一个类 CalcStrategySet，它在并发环境中被多个线程访问。我想知道你们是否可以从下面列出的 2 中建议哪种实现更好。在第一个中，我将变量声明为 volatile 并创建了翻转方法，这是同步的原子操作。其他实现我没有将变量声明为 volatile，但将所有其他方法设为同步。

这些方法是否达到目的并且不会导致竞争条件，如果是，那么哪个更好？

采用易失性和同步原子方法

public class CalcStrategySet {
   private volatile CalcStrategy current;
   private volatile CalcStrategy backup;
   private volatile boolean isBackup;

   public CalcStrategySet(CalcStrategy current, CalcStrategy backup) {
       this.current = current;
       this.backup = backup;
   }

   public void isStandard() {
       return !isBackup;
   }
  
   public void merge(CalcStrategy other) {
      current.merge(other);
   }

   public synchronized void flip() {
      if(!isBackup) {
          current = backup;
          backup = null;
          isBackup = true;
      } else {
          throw new IllegalStateException("Already in backup mode");
      }
   }
}

完全同步

public class CalcStrategySet {
   private CalcStrategy current;
   private CalcStrategy backup;
   private boolean isBackup;

   public CalcStrategySet(CalcStrategy current, CalcStrategy backup) {
       this.current = current;
       this.backup = backup;
   }

   public synchronized void isStandard() {
       return !isBackup;
   }
  
   public synchronized void merge(CalcStrategy other) {
      current.merge(other);
   }

   public synchronized void flip() {
      if(!isBackup) {
          current = backup;
          backup = null;
          isBackup = true;
      } else {
          throw new IllegalStateException("Already in backup mode");
      }
   }
}

Answer 1

这些方法是否达到目的并且不会导致竞争条件，如果是，那么哪个更好？

如果不完全了解类的使用方式以及CalcStrategy.merge() 方法的作用，就很难确定这一点。如果merge() 已经是可重入的，那么第一种机制似乎就足够了。肯定存在竞争条件，这可能意味着电流在 flip(...) 方法到达开关之前得到更新。

担心的是flip(...) 方法可能会转移到备份，但尚未将isBackup 切换为true。例如，一个线程可能在flip(...) 的中间，当前已设置为备份，但另一个线程可能仍看到isStandard() 返回true，因为尚未设置isBackup。多个volatile 字段加剧了这种情况。

改善这种情况的一种方法是将AtomicReference 用于current。这将减少这种竞争条件，并意味着flip() 不需要是synchronized。在下面的代码中，standard 和 backup 是最终的，而不是 volatile。不确定这是否会破坏某些东西。 isStandard() 仍有可能在 flip() 进行更改之前被调用，但这是一种改进。

类似：

private final AtomicReference<CalcStrategy> current = new AtomicReference<>();
private final CalcStrategy standard;
private final CalcStrategy backup;
// no boolean

public CalcStrategySet(CalcStrategy standard, CalcStrategy backup) {
    this.current.set(standard);
    this.standard = standard;
    this.backup = backup;
}

public void isStandard() {
    // no race with isBackup set in flip()
    return (current.get() == standard);
}

// no need for synchronized because one single atomic operation
public void flip() {
   // update to the backup atomically
   if(!current.compareAndSet(standard, backup)) {
       throw new IllegalStateException("Already in backup mode");
   }
}