Question

实现线程安全双向关联的好方法是什么？可能有一个好的库或代码生成器吗？

这是一个非线程安全的例子：

class Foo {

    private Foo other;

    public Foo getOther() {
        return other;
    }

    public void setOther(Foo other) {
        this.setOtherSecretly(other);
        other.setotherSecretly(this);
    }

    void setOtherSecretly(Foo other) {
        if (this.other != null) this.other.other = null;
        this.other = other;
    }
}

我对线程安全的要求是：

没有死锁
最终一致性（当所有线程停止修改对象时，最终会达到一致状态。即，当另一个线程同时执行assert foo.getOther().getOther() == foo时setOther失败是可以接受的。
顺序行为。如果某个线程执行setOther而其他任何线程没有覆盖该值，getOther会立即返回该线程的新值。
没有时光倒流。一旦线程使用getOther观察到新值，它将永远不会再次接收旧值（除非再次设置）。

也很高兴：

低争用，尤其是没有全局锁定。解决方案应该很好地扩展。
尽可能少的同步开销。对于单个线程，它应该具有合理的性能。
内存开销低。当一个对象有5个关联时，我不希望每个关联有3个额外的字段。设置器中的局部变量是可以的。

我的应用程序将有16个线程处理大约5.000个几个类的对象。

我还没有提出解决方案（不，这不是作业），所以欢迎任何输入（想法，文章，代码）。

Answer 1

Google Guava为您完成此操作：BiMap。

例如：

BiMap<Integer, String> bimap = Synchronized.biMap(HashBiMap.create(), someMutexObject);
bimap.put(1, "one");
bimap.put(2, "two");

bimap.get(1); // returns "one"
bimap.inverse().get("one") // returns 1

someMutexObject可以是您想要synchronize开启的任何对象。

Answer 2

您可以将每个对象关联到自己的锁定，然后在获取两个锁定时设置另一个对象。例如。为避免死锁，您可以使用锁定顺序

class Foo extends ReentrantLock {

    private static final AtomicInteger order = new AtomicInteger(0);

    final int id = order.incrementAndGet();

    private Foo other;

    public Foo getOther() {
        return other;
    }

    public void setOther(Foo other) {
        if (id > other.id) {
            other.lock();
            try {
                this.lock();
                try {

                    // assign here
                } finally {
                    this.unlock();
                }
            } finally {
                other.unlock();
            }
        } else if (id < other.id) {
            this.lock();
            try {
                other.lock();
                try {

                    // assign here
                } finally {
                    other.unlock();
                }
            } finally {
                this.unlock();
            }
        }
    }
}

Answer 3

试试这个，在没有写作的情况下允许阅读。

ReentrantReadWriteLock

Answer 4

另一种选择是简单地使other引用变得不稳定。这将满足您的要求和您的好处。

Answer 5

我可以将静态成员视为监视器。但也许这就是你认为的“全球”锁定。

class Foo {

    private static final Object MONITOR = new Object();
    private Foo other;

    public Foo getOther() {
        synchronized(MONITOR){
            return other;
        }
    }

    public void setOther(Foo other) {
        synchronized(MONITOR){
            this.setOtherSecretly(other);
            other.setotherSecretly(this);
        }
    }

    void setOtherSecretly(Foo other) {
        if (this.other != null) this.other.other = null;
        this.other = other;
    }
}

Answer 6

事实证明这是一个非常难的问题！（很好！）使用全局锁定太简单了，而且可能太慢了。我想我有一个无锁版本 - 我将在下面介绍 - 但我不会过分相信它是完美的。很难推断所有可能的交错。

事实证明，这是transactional memory的完美用例！只需将整个块标记为原子并修改您想要的任何内容！您可能会看Deuce STM，但我不知道它有多快。如果只有最好的系统不需要自定义硬件......

无论如何，在考虑了这个问题一段时间之后，我想我想出了一个使用Java AtomicReference来绕过锁的版本。首先，代码：

class Foo {

    private AtomicReference<Foo> oRef = new AtomicReference<Foo>;

    private static final AtomicInteger order = new AtomicInteger(0);
    private final int id = order.incrementAndGet();

    private static bool break(Foo x, Foo y) {
        if (x.id > y.id)
            return break(y, x);

        return x.oRef.compareAndSet(y, null) &&
               y.oRef.compareAndSet(x, null);
    }

    public void setOther(Foo f) {
        if (f != null && f.id > id) {
            f.setOther(this);
            return;
        }
        do {
            Foo other = oRef.get();
            if (other == f)
                break;

            if (other != null && !break(this, other))
                continue;

            if (f == null)
                break;

            Foo fother = f.oRef.get();
            if (fother != null && !break(f, fother))
                continue;

            if (!f.oRef.compareAndSet(null, this))
                continue;
            if (!oRef.compareAndSet(null, f)) {
                f.oRef.set(null);
                continue;
            }
        } while (false);
    }
}

关键点：

如果没有对任何受影响的Foos（最多4个）进行并发访问，则setter会通过循环修改相关指针。
在存在并发setter的情况下，某些setter可能会失败并重试。
如果多个线程试图同时断开关系，则只有一个线程会成功执行x.oRef.compareAndSet(y, null)。
如果f.oRef.compareAndSet(null, f)成功，其他任何线程都无法打破break()中半成熟的关系。然后，如果oRef.compareAndSet(null, f)成功，则操作完成。如果失败，则可以重置f.oRef，并且每个人都会重试。

Java中的Threadsafe双向关联

6 个答案: