无论 java/android 中发生什么，都在准确的时间内完成任务

Question

我知道有很多问题，但或许可以通过冻结另一个任务来获得最接近的结果或使用并行线程？

这是我的代码：

public void draw(Canvas canvas) {
    DrawButtons(canvas);
    DrawPercise(canvas);
    DrawLines(canvas);
}

private void DrawButtons(Canvas canvas) {
    canvas.drawBitmap(Button, 50, 0, null);
        }

private void DrawPercise(Canvas canvas) {

    if (System.nanoTime() >= AllowedTimeinNano) {
       // Save time again for Next if
       //if 50000000 nanoseconds passed do it again
       AllowedTimeinNano = (long) (System.nanoTime() + (20000000000f / 400));

       DoTask();

      }
}

private void DrawLines(Canvas canvas) {

        for (float i = 40; i < 800; i += 40) {
            canvas.drawLine(0, i, 800, i, TablePaint);
        }

    }

问题是，如果我的任务耗时过长或目标设备性能不佳，那么计时就会变得不正确，而应用程序的全部要点都基于此计时。我知道这可能是不可能的，但你能给点提示吗？

Answer 1

我想我会回答这个问题来澄清我在评论中所说的内容。

话题：

public class GameThread extends Thread  {

    private int FPS = 60;
    private double averageFPS;
    private SurfaceHolder surfaceHolder;
    private Clicker gamePanel;
    private boolean running;
    public static Canvas canvas;

    public GameThread(SurfaceHolder surfaceHolder, Clicker gamePanel)
    {
        super();
        this.surfaceHolder = surfaceHolder;
        this.gamePanel = gamePanel;
    }

    @Override
    public void run()
    {
        long startTime;
        long timeMillis;
        long waitTime;
        long totalTime = 0;
        int frameCount =0;
        long targetTime = 1000/FPS;




        while(running) {
            startTime = System.nanoTime();
            canvas = null;

            //try locking the canvas for pixel editing
            try {
                canvas = this.surfaceHolder.lockCanvas();
                synchronized (surfaceHolder) {
                    this.gamePanel.tick();
                    this.gamePanel.draw(canvas);
                }
            } catch (Exception e) {
            }
            finally{
                if(canvas!=null)
                {
                    try {
                        surfaceHolder.unlockCanvasAndPost(canvas);
                    }
                    catch(Exception e){e.printStackTrace();}
                }
            }




            timeMillis = (System.nanoTime() - startTime) / 1000000;
            waitTime = targetTime-timeMillis;

            try{
                sleep(waitTime);
            }catch(Exception e){}

            totalTime += System.nanoTime()-startTime;
            frameCount++;
            if(frameCount == FPS)
            {
                averageFPS = 1000/((totalTime/frameCount)/1000000);
                frameCount =0;
                totalTime = 0;
                System.out.println(averageFPS);
            }
        }
    }
    public void setRunning(boolean b)
    {
        running=b;
    }

}

我上手的时候看教程就搞定了，我也只用过这个。在使用它之前，您需要做一些事情：

有一个 class extends SurfaceView implements SurfaceHolder.Callback
将 'Clicker' 替换为您的 class 的名称。

对于 FPS 计算：

1 秒内的毫秒数/FPS = 更新的频率（以毫秒为单位）

1000 / 60 = 16.666666

这意味着它每 0.01666666 秒更新一次

如何使用？

简单。（要自己找合适的地方放）

正在创建它：

if(gt == null) {
    gt = new GameThread(getHolder(), this);
    gt.setRunning(true);
    gt.start();
}

停止它：

if(gt != null) {
        try {
            gt.setRunning(false);
            gt.join();
            gt = null;

        } catch (InterruptedException e) {
            Toast.makeText(c, "An error occured when stopping the thread.", Toast.LENGTH_LONG)
                    .show();
        }
    }

根据我的经验，60 FPS 是确保这适用于所有设备的最佳 FPS。尽管如此，还是有一些例外。

今天的普通 phone 有 2GB 或更多的内存。例如，S7 有 4 GB 的内存。但是，如果有 512 MB 的内存，我不确定性能。但是世界上只有很少的设备拥有 512 MB RAM。有一些预算 phone，但只有 512 MB RAM 的并不多，除非你 select 真正的旧版本。

因此，通过使用上面的线程，您将拥有一个不断更新且永不停止的游戏线程。您不必担心性能方面的问题，因为大多数新设备运行都是为真正的潜在客户准备的。

此外，该线程的工作方式非常简单：

FPS 是最大 FPS，因此不会更高，因此低端设备将尽可能高至 60，而较新的设备将稳定在 60。

虽然我的 phone 有时会达到 62，但这并不是真正的问题，因为它只有两个 FPS 太多了。

记住：

在游戏线程接触的方法中发生的动作越多，对系统和应用的压力就越大。如果没有限制并且没有任何反应，任何游戏都可以达到 2000 fps。虽然循环很快！

无论 java/android 中发生什么，都在准确的时间内完成任务

Do a task exactly in precise time no matter what in java/android

java

time

android

canvas

draw