尝试创建稳定的游戏引擎循环

Question

我正在编写一个相当简单的 2D 多人网络游戏。现在，我发现自己几乎不可能创建一个稳定的循环。我所说的稳定是指这样一种循环，其中会完成某些计算，并在严格的时间段内重复（比如说，每 25 毫秒，这就是我现在正在争取的）。到目前为止，除了这件事之外，我还没有遇到过太多严重的障碍。

在这个游戏中，服务器和客户端应用程序中都有多个线程正在运行，并分配给各种任务。让我们以我的服务器应用程序中的引擎线程为例。在此线程中，我尝试使用 Thread.sleep 创建游戏循环，尝试考虑游戏计算所花费的时间。这是我的循环，放置在 run() 方法中。 Tick() 函数是循环的有效负载。它仅包含对其他方法进行持续游戏更新的有序调用。

long engFPS = 40;
long frameDur = 1000 / engFPS;
long lastFrameTime;
long nextFrame;

<...>

while(true)
{
    lastFrameTime = System.currentTimeMillis();
    nextFrame = lastFrameTime + frameDur;

    Tick();

    if(nextFrame - System.currentTimeMillis() > 0)
    {
        try
        {
            Thread.sleep(nextFrame - System.currentTimeMillis());
        }
        catch(Exception e)
        {
            System.err.println("TSEngine :: run :: " + e);
        }
    }
}

主要问题是 Thread.sleep 就是喜欢背叛你对它会休眠多少时间的期望。它可以轻松地让线程休眠更长或更短的时间，特别是在某些装有 Windows XP 的机器上（我自己测试过，与 Win7 和其他操作系统相比，WinXP 给出的结果非常糟糕）。我在网上查了很多资料，但结果令人失望。这似乎是我们运行的操作系统的线程调度程序及其所谓的粒度的错误。据我了解，这个调度程序在一定的时间内不断地检查系统中每个线程的需求，特别是将它们从睡眠状态中唤醒/唤醒。当重新检查时间很短（例如 1 毫秒）时，事情可能看起来很顺利。不过，据说WinXP的粒度高达10或15毫秒。我还了解到，不仅 Java 程序员，使用其他语言的程序员也面临这个问题。 知道了这一点，制造一个稳定、坚固、可靠的游戏引擎似乎几乎是不可能的。然而，它们无处不在。 我非常想知道通过什么方法可以解决或规避这个问题。有更有经验的人可以给我提示吗？

Answer 1

不要依赖操作系统或任何计时器机制来唤醒线程或在精确的时间点或精确的延迟后调用某些回调。这不会发生。

处理这个问题的方法是，不要设置睡眠/回调/轮询间隔，然后假设该间隔保持高精度，而是跟踪自上一次迭代以来经过的时间量，并将其用于确定当前状态应该是什么。将此数量传递给基于当前“框架”更新状态的任何内容（实际上，您应该以内部组件不知道或不关心框架等具体事物的方式设计引擎；因此，只有随时间流畅移动的状态，并且当需要发送新帧来渲染该状态的快照时使用）。

例如，您可能会这样做：

long maxWorkingTimePerFrame = 1000 / FRAMES_PER_SECOND;  //this is optional
lastStartTime = System.currentTimeMillis();
while(true)
{
    long elapsedTime = System.currentTimeMillis() - lastStartTime;
    lastStartTime = System.currentTimeMillis();

    Tick(elapsedTime);

    //enforcing a maximum framerate here is optional...you don't need to sleep the thread
    long processingTimeForCurrentFrame = System.currentTimeMillis() - lastStartTime;
    if(processingTimeForCurrentFrame  < maxWorkingTimePerFrame)
    {
        try
        {
            Thread.sleep(maxWorkingTimePerFrame - processingTimeForCurrentFrame);
        }
        catch(Exception e)
        {
            System.err.println("TSEngine :: run :: " + e);
        }
    }
}

另请注意，您可以通过使用 System.nanoTime() 代替 System.currentTimeMillis() 来获得更大的计时器粒度。

Answer 2

但您可能会得到更好的结果

LockSupport.parkNanos(long nanos) 

尽管与 sleep() 相比，它使代码有点复杂，

Answer 3

也许这对你有帮助。
来自 david brackeen 的 bock 用 java 开发游戏
并计算平均粒度以伪造更流畅的帧速率：
链接

public class TimeSmoothie {
    /**
        How often to recalc the frame rate
    */
    protected static final long FRAME_RATE_RECALC_PERIOD = 500;
    /**
            Don't allow the elapsed time between frames to be more than 100 ms

    */
    protected static final long MAX_ELAPSED_TIME = 100;
    /**

        Take the average of the last few samples during the last 100ms

    */
    protected static final long AVERAGE_PERIOD = 100;
    protected static final int NUM_SAMPLES_BITS = 6; // 64 samples
    protected static final int NUM_SAMPLES = 1 << NUM_SAMPLES_BITS;
    protected static final int NUM_SAMPLES_MASK = NUM_SAMPLES - 1;
    protected long[] samples;
    protected int numSamples = 0;
    protected int firstIndex = 0;
    // for calculating frame rate
    protected int numFrames = 0;
    protected long startTime;
    protected float frameRate;

    public TimeSmoothie() {
        samples = new long[NUM_SAMPLES];
    }
    /**
        Adds the specified time sample and returns the average
        of all the recorded time samples.
    */

    public long getTime(long elapsedTime) {
        addSample(elapsedTime);
        return getAverage();
    }

    /**
        Adds a time sample.
    */

    public void addSample(long elapsedTime) {
        numFrames++;
        // cap the time
        elapsedTime = Math.min(elapsedTime, MAX_ELAPSED_TIME);
        // add the sample to the list
        samples[(firstIndex + numSamples) & NUM_SAMPLES_MASK] =
            elapsedTime;
        if (numSamples == samples.length) {
            firstIndex = (firstIndex + 1) & NUM_SAMPLES_MASK;
        }
        else {
            numSamples++;
        }
    }
    /**
        Gets the average of the recorded time samples.
    */

    public long getAverage() {
        long sum = 0;
        for (int i=numSamples-1; i>=0; i--) {
            sum+=samples[(firstIndex + i) & NUM_SAMPLES_MASK];
            // if the average period is already reached, go ahead and return
            // the average.
            if (sum >= AVERAGE_PERIOD) {
                Math.round((double)sum / (numSamples-i));
            }
        }

        return Math.round((double)sum / numSamples);

    }

    /**

        Gets the frame rate (number of calls to getTime() or

        addSample() in real time). The frame rate is recalculated

        every 500ms.

    */

    public float getFrameRate() {

        long currTime = System.currentTimeMillis();



        // calculate the frame rate every 500 milliseconds

        if (currTime > startTime + FRAME_RATE_RECALC_PERIOD) {

            frameRate = (float)numFrames * 1000 /

                (currTime - startTime);

            startTime = currTime;

            numFrames = 0;

        }



        return frameRate;

    }

}