Question

当你关注性能时，在java中实现fetch-and-set的最佳实践是什么？

假设我在某个地方有一个队列尾tail。我自己的节点通过用自身替换尾部来排队，将前一个存储在字段pred中。

目前，我只能想到这样的事情：

public class MyQueue{
    public static class Node{public Node pred = null;}

    public Node tail = new Node(); //sentinel node
}

然后就像......

import sun.misc.Unsafe;

public class MyClass{
    private static long tailOffset = 0;
    public MyClass{
        //ideally, tailOffset can be hardcoded at compile time s.t. this is obsolete
       if(tailOffset <= 0){
           this.tailOffset = unsafe.objectFieldOffset(MyQueue.class.getDeclaredField("tail");
       }
    }

    MyQueue queue = new MyQueue();

    public void createAndInsertNode(){
         Node node = new Node();
         synchronized(node){
             Node pred = queue.tail;
             while(!unsafe.compareAndSwapObject(queue,tailOffset,pred,node)){
                 pred = queue.tail;
             }
             node.pred = pred;
         }
    }

    public static final Unsafe unsafe;
    static {
        try {
            Constructor<Unsafe> unsafeConstructor = Unsafe.class.getDeclaredConstructor();
            unsafeConstructor.setAccessible(true);
            unsafe = unsafeConstructor.newInstance();
        } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException | InstantiationException e) {
            throw new RuntimeException(e);
        }
    }
}

（尚未对代码进行测试，但应该了解相关内容。）

我真的不喜欢在这里使用synchronized，因为它要求我将node.pred的所有访问权限也放到synchronized(node)块中。

基本上，我想要的只是

public void createAndInsertNode(){
     Node node = new Node();
     node.pred = FetchAndSet(queue.tail,node);
}

整个语句第二行是原子的。有什么东西可以允许吗？

Answer 1

无需直接使用Unsafe来执行此类任务。

避免同步块的一个解决方案是使用原子引用。它最终将使用您打算使用的相同CAS指令。

@ThreadSafe
public class MyQueue {
  public static class Node {
    public Node pred = null;
  }

  public final AtomicReference<Node> tail = new AtomicReference<>(new Node());

  public void insertNewNode() {
    Node node = new Node();
    node.pred = tail.getAndSet(node);
  }
}

如何在java中最好地实现“fetch-and-set”？

1 个答案: