消除僵局

Question

我目前正在（尝试）编写一个小游戏。我有一个小的设计/死锁问题。

当我按下按钮时，会打开一个新的 Intent，并且 surfaceDestroyed 设置一个布尔值来设置线程休眠。 当我返回时，线程收到通知信号。

这在大约 90% 的情况下有效（当我使用 eclipse 调试时为 100%）。

我相信死锁发生在线程的run函数中（两个synchronized）。问题是，wait() 需要线程的同步，而 ondraw() 需要表面持有者上的锁。

我已经玩了一下，但所有其他组合都会让一切变得更糟，我不知道如何解决这个问题。所以请帮忙:)

主题：

class BattleEarthThread extends Thread {
    private SurfaceHolder _surfaceHolder;
    private BattleEarthView _battleEarthView;
    private boolean _run = false;
    private boolean _suspended = false;

    public SurfaceHolder getSurfaceHolder() {
        return _surfaceHolder;
    }

    public BattleEarthThread(SurfaceHolder surfaceHolder, BattleEarthView panel) {
        _surfaceHolder = surfaceHolder;
        _battleEarthView = panel;
    }

    public void setRunning(boolean run) {
        _run = run;
    }

    public void setSuspend(boolean suspend) {
        _suspended = suspend;
    }

    public boolean getSuspended() {
        return _run;
    }

    public boolean getRunning() {
        return _run;
    }

    @Override
    public void start() {
        super.start();
        _run = true;
    }

    @Override
    public void run() {
        Canvas c;
        while (_run) {
            c = null;
            try {
                synchronized(this)
                {
                        c = _surfaceHolder.lockCanvas(null);
                        synchronized (_surfaceHolder) {

                            if(_suspended)
                                this.wait();

                            else {
                                _battleEarthView.onDraw(c);
                            }
                        }
                    }
            } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                if (c != null) {
                    _surfaceHolder.unlockCanvasAndPost(c);
                }
            }
        }
    }
}

Answer 1

这就是问题所在：

synchronized(this) {
    c = _surfaceHolder.lockCanvas(null);
    synchronized (_surfaceHolder) {

        if(_suspended)
            this.wait();

        else {
            _battleEarthView.onDraw(c);
        }
    }
}

您取出了两把锁 - this 和 _surfaceHolder。然后，您通过调用 wait释放 this 上的锁...但您仍然拥有 _surfaceHolder 的锁>。

现在假设另一个线程在同一个对象上执行相同的代码。它设法获取 this 的锁，因为目前没有其他线程拥有它......但在尝试获取 _surfaceHolder 时它会阻塞，因为等待线程拥有它。

此时，您已经被塞满了：

• 没有线程可以获取正在等待的对象上的锁，因为第二个线程拥有它
• 即使另一个线程可以脉冲该锁，等待线程仍然需要在继续之前重新获取 this 上的锁，这是它无法做到的。

所以基本上你有两个线程，每个线程都拥有一个锁，并且正在等待不可能发生的事情发生。这与正常的死锁（每个线程拥有一个锁并等待另一个线程的锁）不同，但也非常接近。

寓意：不要在当前“拥有”比要调用 wait() 的监视器更多的线程上调用 wait()。