java - 多个线程更新 surfaceview Canvas

Question

从事咨询项目。最后一分钟的要求是球在屏幕上弹跳(不要问为什么......叹气)

无论如何...这些球是按值分组的。 10 个球是红色的，值(value) 100 分。 5 个球是蓝色的，值(value) 50 分。 5 个球是绿色的，值(value) 25 分。 5 个球是黄色的，值(value) 10 分。

在这种背景下，我采用的方法是扩展 SurfaceView 并定义 5 个线程，每个线程管理一组特定的球。

每个线程从 SurfaceView 接收相同的 SurfaceHolder。

我之所以选择多个线程而不是一个线程，是因为管理屏幕上所有球的性能并不是最好的。

OpenGL 现在并不是一个真正的选择。

这是其中一个线程类的示例。当线程运行时，它会创建一定数量的球。每个球都是随机创建的并添加到列表中。

public class hundred_balls_thread extends base_balls_thread {
    public hundred_balls_thread(SurfaceHolder holder, Context ctext, int radius) {
        super(holder, ctext, radius);
    }

    @Override
    public void run() {
        int x, y, radius;

        while (Calorie_balls.size() <= 21) {

            x = 100 + (int) (Math.random() * (mCanvasWidth - 200));
            y = 100 + (int) (Math.random() * (mCanvasHeight) - 200);
            radius = mRadius;

            if ((x - mRadius) < 0) {
                x = x + mRadius;
            }

            if ((x + mRadius) > mCanvasWidth) {
                x = x - mRadius;
            }

            if ((y + mRadius) > mCanvasHeight)
                y = y - mRadius;

            if ((y - mRadius) < 0)
                y = y + mRadius;

            calorie_ball ball = new calorie_ball(x, y, radius, context.getResources().getColor(R.color.red100ball), "100");

            boolean addit = true;

            Calorie_balls.add(ball);
        }

        super.run();
    }
}

这是它们都扩展的基类:

public class base_balls_thread extends Thread {
    protected int mCanvasWidth;
    protected int mCanvasHeight;
    protected int mRadius;
    protected Context context;

    public ArrayList<calorie_ball> Calorie_balls = new ArrayList<calorie_ball>(); // Dynamic array with dots

    private SurfaceHolder holder;
    private boolean running = false;
    private final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    private final Paint text_paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    private final int refresh_rate = 100;      // How often we update the screen, in ms

    public base_balls_thread(SurfaceHolder holder, Context ctext, int radius) {
        this.holder = holder;
        context = ctext;
        mRadius = radius;
    }

    @Override
    public void run() {
        long previousTime, currentTime;
        previousTime = System.currentTimeMillis();
        Canvas canvas = null;

        while (running) {
            // Look if time has past
            currentTime = System.currentTimeMillis();
            while ((currentTime - previousTime) < refresh_rate) {
                currentTime = System.currentTimeMillis();
            }

            previousTime = currentTime;

            try {

                // PAINT
                try {
                    canvas = holder.lockCanvas();
                    synchronized (holder) {
                        draw(canvas);
                    }
                } finally {
                    if (canvas != null) {
                        holder.unlockCanvasAndPost(canvas);
                    }
                }
                // WAIT
                try {
                    Thread.sleep(refresh_rate); // Wait some time till I need to display again
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } catch (Exception eal) {
                String msg = eal.getMessage();
                if (msg == null)
                    msg = "Blahbla";
            }
        }

    }

    // The actual drawing in the Canvas (not the update to the screen).
    private void draw(Canvas canvas) {

//        dot temp_dot;
        canvas.drawColor(Color.BLACK);
        paint.setStyle(Paint.Style.FILL_AND_STROKE);
        paint.setStrokeWidth(4);

        text_paint.setColor(Color.BLACK);
        text_paint.setTextSize(40);

        try {
            for (calorie_ball crcl : Calorie_balls) {
                paint.setColor(crcl.color);
                paint.setShader(new RadialGradient(crcl.x + 10, crcl.y, crcl.radius * 2, crcl.color, Color.BLACK, Shader.TileMode.CLAMP));
                if (crcl.x + crcl.radius < 0 && crcl.y + crcl.radius < 0) {
                    crcl.x = canvas.getWidth() / 2;
                    crcl.y = canvas.getHeight() / 2;
                } else {
                    crcl.x += crcl.xVelocity;
                    crcl.y += crcl.yVelocity;

                    if ((crcl.x > canvas.getWidth() - crcl.radius) || (crcl.x - crcl.radius < 0)) {
                        crcl.xVelocity = crcl.xVelocity * -1;
                    }
                    if ((crcl.y > canvas.getHeight() - crcl.radius) || (crcl.y - crcl.radius < 0)) {
                        crcl.yVelocity = crcl.yVelocity * -1;
                    }
                }

                String calval = crcl.get_calorie_value();
                int x = crcl.x + 5;
                int y = crcl.y + 5;

                canvas.drawCircle(crcl.x, crcl.y, crcl.radius, paint);
                canvas.drawText(calval, x, y, text_paint);
            }

        } catch (Exception ep) {
            String b = ep.getMessage();
            if (b == null)
                b = "blah";
        }
    }

    public void setRunning(boolean b) {
        running = b;
    }

    protected Canvas myCanvas;
    protected Bitmap cvsBmp;
    protected Matrix identityMatrix;

    public void setSurfaceSize(int width, int height) {
        synchronized (holder) {
            mCanvasWidth = width;
            mCanvasHeight = height;
        }
    }
}

发生的事情是，如果它只是一个线程......它工作正常。一旦我引入第二个线程，混合...说一个 HUNDRED_BALLS_THREAD 和一个 FIFTY_BALLS_THREAD，那时候一切都变得疯狂了。

线程“有效”，如果你想这样调用它......但屏幕不断闪烁。

我知道其中的原因对你们中的一些人来说可能是显而易见的，但不幸的是我不明白为什么。

我假设因为每个线程都在锁定 Canvas ...它会等待。

有什么办法解决这种闪烁？我的设计决定是完全错误的吗？我敢肯定这是因为每个线程都在访问同一个 Canvas ......但我认为这会导致它像那样闪烁。

Answer 1

SurfaceView 的 Surface 是双缓冲或三缓冲的。每次调用 unlockCanvasAndPost() 都会向合成器提交一个新缓冲区。如果您每次只渲染场景的 1/5(我们称之为 A-B-C-D-E)，那么您将得到一个只有“A”球的帧，然后一个只有“B”球的帧，依此类推。这假设您的线程是按循环调度的，而它们通常不在 Android/Linux 上。我怀疑您看到闪烁是因为您基本上以 50fps 的速度运行，一次只显示一组对象。

如果您不每次都清除 Canvas，故障将不那么明显，因为 Android 不会为您清除 Canvas。因此，您从前面的前缓冲区的内容开始，这可能是一组不同的球。

系统在 Canvas 锁定时提供独占访问。您可以尝试将 SurfaceHolder 的(应该是不必要的)锁定移动到 Canvas 锁定/解锁之外，看看它是否有所作为。

有关完整说明，请参阅 Android System-Level Graphics Architecture文档。

就您的情况而言，虽然您可以让多个线程更新球的位置等状态，但很难让多个线程共享一个 Canvas 进行渲染。如果你真的想在软件中完成这一切，试试这个:创建一个位图，并使用尽可能多的线程自己渲染圆圈(使用 Bresenham 或位图)。定期让一个线程卡住位图，锁定 Canvas ，然后将位图 blit 到它。

如果您想要一些简单的 2D GLES 渲染示例，请参阅 Grafika或 Android Breakout (后者使用 Bresenham 生成圆形球纹理)。