SurfaceHolder的lockCanvas和unlockCanvasAndPost的同步

Question

我知道有很多关于这个话题的问题，但是，我仍然对所提供的答案并不完全满意。

情况： 我使用 SurfaceHolder 在另一个线程中实现了 SurfaceView，就像开发人员指南中建议的那样：http://developer.android.com/guide/topics/graphics/2d-graphics.html

问题： 有时我会得到 java.lang.IllegalStateException: Surface has been released:

• 调用 SurfaceHolder.lockCanvas() 时
• 或在调用 SufraceHolder.unlockCanvasAndPost() 时

这意味着我的表面有时会在我锁定画布之前释放，有时 - 在锁定和解锁之间。

我的解决方案： 我在同步块中执行表面检查和锁定/解锁画布，所以我确定表面不会在这些操作之间被破坏。但是，我从未使用过同步块，我想问一下它是否有任何问题。到目前为止，代码运行良好，但您永远不知道什么时候会出现同步问题，所以我不完全相信这是最好的方法。

private class DrawingThread extends Thread{
    @Override
    public void run() {
        super.run();
        while (!isInterrupted() && holder != null) {
            Canvas drawingCanvas = null;
            synchronized (this) {
                if (holder.getSurface().isValid()) {
                    drawingCanvas = holder.lockCanvas();
                }
            }
            if (drawingCanvas != null && drawingCanvas.getWidth() > 0) {
                drawThisView(drawingCanvas);
                synchronized (this) {
                    if(holder.getSurface().isValid()) {
                        holder.unlockCanvasAndPost(drawingCanvas);
                    }
                }
            }
        }
    }
}


@Override
public void surfaceCreated(SurfaceHolder holder) {
    if(drawingThread != null){
        drawingThread.interrupt();
    }
    drawingThread = new DrawingThread();
    drawingThread.start();
}

@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    if(drawingThread.isInterrupted()){
        drawingThread = new DrawingThread();
        drawingThread.start();
    }
}

@Override
public void surfaceDestroyed(SurfaceHolder holder) {
    drawingThread.interrupt();
}

Answer 1

synchronized 语句用于多个线程之间的互斥访问。如果您在线程#1 中synchronized (this)，那么任何其他尝试执行相同操作的线程都会阻塞，直到线程#1 退出同步块。

如果你只在一个线程中使用它，它没有任何用处。当然，如果您有多个线程试图锁定和解锁 Surface 的 Canvas，您应该首先不这样做，而不是尝试在事后强制执行独占访问来解决问题。

您对interrupt() 和isThreadInterrupted() 的使用没有多大意义。如果你想提高一个标志来告诉线程该停止运行了，volatile boolean 就可以了。 interrupt() 的唯一优点是，如果它正在等待对象发出信号，它将唤醒线程。此外，请考虑isInterrupted() 调用的文档：

返回一个布尔值，指示接收器是否有待处理中断请求（真）或没有（假）

（强调我的。）您的代码允许诸如“如果线程处于活动状态，但已为其引发中断，则继续并在旧线程仍在运行时创建一个新线程”之类的情况。

有关使用 SurfaceView 的一些信息可以在this appendix 中找到。该链接指向 Grafika 中基于 Surface 回调启动和停止线程的示例，您可以找到 here。

Answer 2

经过几个小时的反复试验，我想我已经弄明白了。毕竟，我所要做的就是阅读 android 参考。以下是我弄错的一些重要事项：

• SurfaceHolder.getSurface.isValid() 只检查表面是否可以 被锁定，因此此检查可能（并且确实）失败，因为看到的是画布 可以解锁。
• 检查是否可以拨打unlockCanvasAndPost()， 您只需检查lockCanvas() 返回的canvas 是否不是 null。
• 如果canvas 是null，你不应该解锁它（如果你 试试会抛出异常）。
• 如果它不为空，你必须解锁它，否则如果你的活动试图停止你的应用程序将冻结（在onPause()之后SurfaceHolder试图破坏Surface，但由于Canvas被锁定，它不能，所以你陷入了僵局）。

希望这可以帮助其他“菜鸟”。最后，这是我对SurfaceView 的最终代码（不再需要try/catch 块）：

DrawingThread drawingThread;

private class DrawingThread extends Thread{
    public volatile boolean canDraw = true;

    @Override
    public void run() {
        try {
            while (canDraw) {
                Canvas drawingCanvas = null;
                if (canDraw && holder.getSurface().isValid()) {
                    drawingCanvas = holder.lockCanvas();
                    if (drawingCanvas != null) {
                        drawThisView(drawingCanvas);
                        holder.unlockCanvasAndPost(drawingCanvas);
                    }
                }
            }
        }catch(IllegalStateException e){
            e.printStackTrace();
            canDraw = false;
        }
    }
}


@Override
public void surfaceCreated(SurfaceHolder holder) {
    if(drawingThread != null){
        drawingThread.canDraw = false;
    }
    drawingThread = new DrawingThread();
    drawingThread.start();
}

@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    if(!drawingThread.canDraw){
        drawingThread = new DrawingThread();
        drawingThread.start();
    }
}

@Override
public void surfaceDestroyed(SurfaceHolder holder) {
    if(drawingThread != null) {
        drawingThread.canDraw = false;
    }
}

感谢 fadden 澄清了有关在另一个线程中绘图的一些要点。

Answer 3

我遇到了同样的问题 - 使用后台线程在 SurfaceView 中绘图，有时，活动关闭时应用程序挂起。追踪显示，在这种情况下，表面在lockCanvas 和unlockCanvasAndPost 之间被破坏。

似乎这种行为的原因是我对文档的解释有点错误。 Callback.surfaceDestroyed 必须用于防止表面被破坏（通过不从表面返回），直到后台线程完成表面。

DrawingThread drawingThread;
ReentrantLock paintLock = new ReentrantLock();

private class DrawingThread extends Thread{
    public volatile boolean canDraw = true;

    @Override
    public void run() {
        try {
            while (canDraw) {
                Canvas drawingCanvas = null;
                paintLock.lock();
                if (canDraw)) {
                    drawingCanvas = holder.lockCanvas();
                    if (drawingCanvas != null && drawingCanvas.getWidth() > 0) {
                        drawThisView(drawingCanvas);
                        holder.unlockCanvasAndPost(drawingCanvas);
                    }
                }
                paintLock.unlock();
            }
        }catch(IllegalStateException e){
            e.printStackTrace();
            canDraw = false;
        }
    }
}

...

@Override
public void surfaceDestroyed(SurfaceHolder holder) {
    paintLock.lock();
    if(drawingThread != null) {
        drawingThread.canDraw = false;
    }
    paintLock.unlock();
}

Answer 4

将 Lock、Draw 和 Unlock 放在单个同步语句中修复了异常。

我是在阅读了这个帖子后才知道同步语句的，如果这是一个坏主意，请纠正我。

private class DrawingThread extends Thread{
@Override
public void run() {
    super.run();
    while (!isInterrupted() && holder != null) {
        Canvas drawingCanvas = null;
        synchronized (this) {
            if (holder.getSurface().isValid()) {
                drawingCanvas = holder.lockCanvas();
            }

            if (drawingCanvas != null && drawingCanvas.getWidth() > 0) {
                drawThisView(drawingCanvas);
            }

            if(holder.getSurface().isValid()) {
                 holder.unlockCanvasAndPost(drawingCanvas);
            }
        } // Lock -> Draw -> Unlock in a single synchronised statement

      }
   }
}