10

我熟悉 Java 中围绕并发的许多机制和习语。我感到困惑的是一个简单的概念：同一对象的不同成员的并发访问。

我有一组可以由两个线程访问的变量，在这种情况下涉及游戏引擎中的图形信息。我需要能够在一个线程中修改对象的位置并在另一个线程中读取它。解决这个问题的标准方法是编写以下代码：

private int xpos;
private object xposAccess;

public int getXpos() {
    int result;
    synchronized (xposAccess) {
        result = xpos;
    }
    return result;
}

public void setXpos(int xpos) {
    synchronized (xposAccess) {
        this.xpos = xpos;
    }
}

但是，我正在编写一个实时游戏引擎，而不是 20 个问题的应用程序。我需要快速工作，尤其是当我像访问和修改图形资产的位置一样频繁地访问和修改它们时。我想删除同步开销。更好的是，我想完全删除函数调用开销。

private int xpos;
private int bufxpos;
...

public void finalize()
{
    bufxpos = xpos;
    ...
}

使用锁，我可以让线程互相等待，然后在对象未被访问或修改时调用 finalize()。在这个快速缓冲步骤之后，两个线程都可以自由地作用于对象，一个修改/访问 xpos，一个访问 bufxpos。

我已经使用类似的方法取得了成功，其中信息被复制到第二个对象中，并且每个线程都作用于一个单独的对象。然而，在上面的代码中，两个成员仍然是同一个对象的一部分，当我的两个线程同时访问该对象时，一些有趣的事情开始发生，即使对不同的成员进行操作也是如此。不可预测的行为、幻影图形对象、屏幕位置的随机错误等。为了验证这确实是一个并发问题，我在一个线程中运行了两个线程的代码，它完美地执行。

我希望性能高于一切，我正在考虑将关键数据缓冲到单独的对象中。我的错误是由对相同对象的并发访问引起的吗？有没有更好的并发解决方案？

编辑：如果你怀疑我对业绩的评价，我应该给你更多的背景信息。我的引擎是为 Android 编写的，我用它来绘制成百上千的图形资源。我有一个可以工作的单线程解决方案，但是自从实施多线程解决方案以来，我看到性能几乎翻了一番，尽管存在幻像并发问题和偶尔的未捕获异常。

编辑：感谢关于多线程性能的精彩讨论。最后，我能够通过在工作线程处于休眠状态时缓冲数据来解决问题，然后允许它们在对象中各自拥有自己的数据集进行操作。

4

3 回答 3

4

如果您只处理单个基元，例如AtomicInteger具有类似 的操作的compareAndSet，那就太好了。它们是非阻塞的，您可以获得大量的原子性，并在需要时回退到阻塞锁。

对于以原子方式设置访问变量或对象，您可以利用非阻塞锁，回退到传统锁。

但是，从您在代码中的位置向前迈出的最简单的一步是使用synchronized但不使用隐式对象，而是使用几个不同的成员对象，this每个需要原子访问的成员分区一个： .synchronized(partition_2) { /* ... */ }synchronized(partition_1) { /* ... */ }private Object partition1;private Object partition2;

但是，如果成员不能被分区，那么每个操作必须获得多个锁。如果是这样，请使用Lock之前链接的对象，但要确保所有操作都以某种通用顺序获取所需的锁，否则您的代码可能会死锁。

更新：volatile即使对性能造成不可接受的影响，也可能真的不可能提高性能。您无法解决的基本基本方面是互斥必然意味着权衡内存层次结构的实质性好处，即缓存。最快的每处理器内核内存缓存不能保存您正在同步的变量。处理器寄存器可以说是最快的“缓存”，即使处理器足够复杂以保持最近的缓存一致，它仍然排除在寄存器中保存值。希望这可以帮助您了解它是性能的基本障碍，并且没有魔杖。

在移动平台的情况下，出于电池寿命的考虑，该平台被刻意设计为不让任意应用程序尽可能快地运行。让任何一个应用程序在几个小时内耗尽电池并不是优先事项。

考虑到第一个因素，最好的办法是重新设计您的应用程序，以便它不需要那么多的互斥——考虑不一致地跟踪 x-pos，除非两个对象彼此靠近，比如在 10x10 的盒子内。因此，您锁定了一个 10x10 框的粗网格，并且只要一个对象在其中，您就会不一致地跟踪位置。不确定这是否适用于您的应用程序或是否有意义，但这只是传达算法重新设计精神的一个示例，而不是寻找更快的同步方法。

于 2013-08-28T21:42:33.540 回答
2

I don't think that I get exactly what you mean, but generally

Is there a better solution for concurrency?

Yes, there is:

于 2013-08-28T18:51:00.397 回答
1

我认为使用不可变对象进行线程间通信可以避免同步或任何类型的锁定。假设要发送的消息如下所示：

public final class ImmutableMessage {
    private final int xPos;
    // ... other fields with adhering the rules of immutability

    public ImmutableObject(int xPos /* arguments */) { ... }

    public int getXPos() { return xPos; }
}

然后在作家线程的某个地方：

sharedObject.message = new ImmutableMessage(1);

读者线程：

ImmutableMessage message = sharedObject.message;
int xPos = message.getXPos();

共享对象（为了简单起见的公共字段）：

public class SharedObject {

    public volatile ImmutableMessage message;
}

我猜在实时游戏引擎中事情会迅速变化，最终可能会创建大量ImmutableMessage对象，最终可能会降低性能，但可能会通过该解决方案的非锁定性质来平衡。

最后，如果您有一个小时的空闲时间来学习这个主题，我认为值得观看Angelika Langer 的这个关于 Java 内存模型的视频。

于 2013-08-28T19:18:16.920 回答