Question

当我想对单个变量进行比较和设置时，它非常简单：

enum State {ON, OFF, BROKEN};
AtomicReference<State> state = new AtomicReference<>(State.OFF);

void turnOn() { state.compareAndSet(State.OFF, State.ON); }

但是，如果我想比较一个变量并设置另一个变量，那么我必须使用其他一些锁定机制：

enum Direction {LEFT, RIGHT};
State state;
Direction direction;

void turnOn() {
  synchronized(state) {
    if (state == state.OFF) state = State.ON
  }
}

void pointLeft() {
  synchronized(state) {
    if (state == State.ON) {
      direction = Direction.LEFT;
    }
  }
}

如果我需要state在执行我的关键部分的整个过程中保持“开启”，这种解决方案是必要的。其他线程读取状态很好，但重要的是它不能改变。

在这个例子中，“左点”代码相当快，但在我的实际应用中，synchronized块可能会大得多。另外，它使我在简单的turnOn方法中包含同步，而不是使用现有的比较和设置逻辑。

Answer 1

创建一个同时执行状态更改的同步方法，或者创建一个不可变类，其实例表示双重状态，并使用AtomicReference：

public class DirectionState {
    private final Direction direction;
    private final State state;
    // rest of class omitted
}


private AtomicReference<DirectionState> ref = new AtomicReference<>(new DirectionState(Direction.LEFT, State.OFF));

并使用它来单独更改字段：

// locking code removed
void turnOn() {
    DirectionState directionState = ref.get();
    directionState.compareAndSet(directionState, new DirectionState(directionState.getDirection(), State.ON));
}
// similar for pointLeft()

和在一起

void set(Direction direction, State state) {
    ref.set(new DirectionState(direction, state));
}

Answer 2

您的第二个代码示例无效。您正在同步要更改的成员变量。这意味着不同的线程可能（可能？）获得不同的锁。这意味着代码根本不安全。

您可以使用Lock或其他不可变对象进行同步。

enum Direction {LEFT, RIGHT};
private final Lock lock = new ReentrantLock();
State state;
Direction direction;

void turnOn() {
  lock.lock();
  try {
    if (state == state.OFF) state = State.ON
  } finally {
    lock.unlock();
  }
}

void pointLeft() {
  lock.lock();
  try {
    if (state == State.ON) {
      direction = Direction.LEFT;
    }
  } finally {
    lock.unlock();
  }
}

Answer 3

您的问题中发布的代码不需要任何原子修改，因为没有原子读取可能受修改原子性影响的两个值。

让我们看一下这两种方法（在修复使用可变变量的内容作为互斥锁的错误之后）：

void turnOn() {
  synchronized(this) {
    if (state == state.OFF) state = State.ON
  }
}

void pointLeft() {
  synchronized(this) {
    if (state == State.ON) {
      direction = Direction.LEFT;
    }
  }
}

关于turnOn()的并发调用，结果没有区别。如果同时调用两个方法，则有两种情况：

线程设法在synchronized turnOn()块synchronized之前完成pointLeft() pointLeft()块。
synchronized在线程进入synchronized turnOn()块{/ 1}}之前完成state阻止的所有尝试
在任何一种情况下，如果至少调用了一个线程State.ON，则turnOn()变量将包含值BROKEN（假设状态不是direction）并且Direction.LEFT将根据不可预测的线程时序或此类范围之外的线程间依赖关系更改为AtomicReference或保持不变。

现在，如果我们在您的第一个版本中使用final AtomicReference<State> state = new AtomicReference<>(State.OFF); void turnOn() { state.compareAndSet(State.OFF, State.ON); } void pointLeft() { if(state.get() == State.ON) direction = Direction.LEFT; }，会发生什么？
```
AtomicReference.get
```
compareAndSet是一个原子操作，所以在并发场景中我们仍然只有两种可能的场景：
1. 在get
2. get

如何自动比较和设置不同的变量？

3 个答案: