1

可以说我有下一个方法：

public synchronized void remap(UnaryOperator<X> update) {
    this.memory = update.apply(this.memory);
    inferDispatch();
}

其中 memory 是一个 volatile X 变量；

为了更新 XI 可以设置 X(X x)，我已经有一个选项。但我还需要从内部“重新映射”它，同时是超轻量级（我不想使用 AtomicReference）。

另一种选择是......，而不是 UnaryOperator，使用消费者，当然要求是消费者中定义的任何操作都不能同时完成......

那么如果该方法的目标是 AtomicReference，其思想是 Memory 作为 ligthweigth 类，没有完整的线程安全属性，那么它可以继承它们吗？：

Memory<AtomicReference<X>> memory = new Memory(new AtomicReference());

memory.remap(xAtomicReference -> {
                            xAtomicReference.updateAndGet(
                                    x -> operator.transform(xAtomicReference.get())
                            );
                            return xAtomicReference;
                        }
                );

在这种情况下，“重新映射”将是有益的，但这this.memory = update.apply(this.memory);并没有给我任何信心。

我假设 .getMemory().get() 的线程（第二个 get() 来自 AtomicReference 本身）对内存的引用，在执行 remap() 时会丢失原子属性，因为“ =" 操作数重新分配 volatile X 变量...

我应该使用 Consumer 而不是 UnaryOperator 吗？

4

0 回答 0