是否有可能在Java中有效地实现seqlock？

另一个question让我想知道是否可以使用Java中的易失版本计数器有效地实现seqlock.

这是一个原型实现,因为只有一个编写器线程的情况：

class Seqlock {
  private volatile long version = 0;
  private final byte[] data = new byte[10];

  void write(byte[] newData) {
    version++;  // 1
    System.arraycopy(newData, 0, data, 0, data.length);  // 2
    version++;  // 3
  }

  byte[] read() {
    long v1, v2;
    byte[] ret = new byte[data.length];
    do {
      v1 = version; // 4
      System.arraycopy(data, 0, ret, 0, data.length);  // 5
      v2 = version; // 6
    } while (v1 != v2 || (v1 & 1) == 1);
  }
}

基本思想是在写入之前和之后增加版本号,并且读者通过验证版本号是否相同而检查它们是否获得“一致”读取,因为奇数表示“正在写入”.

由于版本是易变的,因此在编写器线程和读取器线程中的关键操作之间存在各种发生之前的关系.

但是,我不能看到是什么阻止了(2)处的写入向上移动(1)并因此导致读者看到正在进行的写入.

例如,易失性读取和写入的以下同步顺序,使用每行旁边的注释中的标签(还显示非易失性的数据读写,因此不是同步顺序的一部分,缩进)：

1a (version is now 1)
  2a (not part of the synchronization order)
3 (version is now 2)
4 (read version == 2, happens before 3)
  5 (not part of the synchronization order)
6 (read version == 2, happens before 4 and hence 3)
1b (second write, version is now 3)
  2b (not part of the synchronization order)

ISTM没有发生 – 在5(读取数据)和2b(第二次写入数据)之前没有发生,因此2b可能在读取和读取错误数据之前发生.

如果这是真的,是否将write()声明为同步帮助？

解决方法:

在java中,您可以非常简单地实现共享缓冲区(或其他对象)：

public class SharedBuffer {

  private volatile byte[] _buf;

  public void write(byte[] buf) {
    _buf = buf;
  }

  public byte[] read() {
    // maybe copy here if you are worried about passing out the internal reference
    return _buf;
  }
}

显然,这不是“seqlock”.

标签：java,optimization,concurrency,mutex,java-memory-model
来源： https://codeday.me/bug/20190703/1371570.html