Question

我熟悉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编写的，我使用它来绘制数百或数千个图形资源。我有一个单线程解决方案，但是自从实现多线程解决方案以来，我看到性能几乎翻了一番，尽管存在幻像并发问题和偶尔的未捕获异常。

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

Answer 1

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

对于原子设置访问变量或对象，您可以利用non-blocking锁定，回退到传统锁定。

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

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

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

对于移动平台，该平台是故意设计的，以防止任意应用程序尽快运行，因为电池寿命问题。让任何一个应用程序在几个小时内耗尽电池并不是一个优先事项。

鉴于第一个因素，最好的办法是重新设计你的应用程序，使其不需要那么多的互斥 - 考虑跟踪x-pos不一致，除非两个物体彼此靠近说10x10内框。所以你已经锁定了10x10盒子的粗网格，只要一个物体在它内部，你就会不一致地跟踪位置。不确定这是否对您的应用程序适用或有意义，但它只是传达算法重新设计的精神而不是搜索更快的同步方法的示例。

Answer 2

我不认为我得到你的意思，但通常是

是否有更好的并发解决方案？

是的，有：

更喜欢Java Lock API而不是内在的内置锁。
考虑使用atomic API中提供的非阻止结构，例如AtomicInteger，以获得更好的效果。

Answer 3

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

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对象，最终可能会降低性能，但可能会被非锁定性质所平衡这个解决方案。

最后，如果您有一个空闲时间来讨论这个主题，我认为值得关注this video about the Java Memory Model by Angelika Langer。

同时访问Java中同一对象的不同成员

3 个答案: