java - 无论在 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;
    }

}

我上手的时候看教程的时候就得到了，而且我只用过这个。在使用它之前，您必须执行一些操作:

• 有一个类扩展 SurfaceView 实现 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。尽管如此，还是有一些异常(exception)。

现在的普通手机有 2GB 或更多内存。例如，S7 有 4 GB 内存。然而，如果有 512 MB 的内存，我不确定性能。但世界上拥有 512 MB RAM 的设备所剩无几。有一些廉价手机，但只有 512 MB RAM 的手机并不多，除非您选择非常旧的版本。

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

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

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

虽然我的手机有时会达到 62 帧，但这并不是真正的问题，因为它只多了 2 FPS。

记住:

游戏线程涉及的方法中发生的操作越多，对系统和应用程序的压力就越大。如果没有限制且没有任何反应，任何游戏都可以达到 2000 fps。 While 循环速度很快!