Thread.sleep() Inaccuracy

Newbie & Debugging Questions
#1

Hello,

I recently started developing games in Java. But I cant get pass one problem. I searched the web and didnt find any answer, so I entered this forums.

My problem is the following: Thread.sleep(time) is not being as good as it should be. Here some example:


	public static void main(String[] args) {
		while (true){
			sleep(20);
		}
		
	}

	private static void sleep(int i) {
		long startingtime = System.nanoTime();
		
		try {Thread.sleep(i);} 
		catch (InterruptedException e) {e.printStackTrace();}
		
		long endingtime = System.nanoTime();
		
		double slepttime = (endingtime - startingtime ) /1000000.0;
		System.out.println("Expected: "+i+" Real: "+slepttime);
		
	}

On my Windows7 Pc I get results like:
Expected: 20 Real: 19.929772
Expected: 20 Real: 19.881132
Expected: 20 Real: 19.908117
Expected: 20 Real: 19.919111
Expected: 20 Real: 19.911116
Expected: 20 Real: 19.899788
Expected: 20 Real: 19.889128
Expected: 20 Real: 19.906784

But on WindowsXP Pc’s these results are really bad.
Ej:

Expected: 20 Real: 18,7034
Expected: 20 Real: 29.2780
Expected: 20 Real: 26.14
Expected: 20 Real: 20.1889
Expected: 20 Real: 27.4749
Expected: 20 Real: 16.6664

My question is: whats the method you guys use to make gameloop wait? Because Thread.sleep() doesn’t seem to be a really good way.

Thanks!

#2

THis is the way to do it really.
You need to compensate the sleep errors with code.

You could try extracting or adding the oversleep time to the sleep time of the next frame.

#3

You can also “burn off” cycles.
Using a while loop with Many Thread.yield , checking every run if you have burned off enough time yet.
Continue with execution when you have reached the threshold

#4

I just don’t make my game loop wait^^
I really don’t get why so many people around here use some trickery to get around 60 frames per second, there is no need for that even for fixed time steps.
One always hears about games running 60 fps, but I think most don’t get that this has something to do with vsync(monitor refresh rate). And this has to be activated with OpenGL, which will then automaticly get your rendering down to 60fps(in most cases). So If you want a framerate of 60Hz just enable Vsync.

If you are using software rendering(i.e. Java2D), which doesn’t support vsync and you don’t want to run at full speed(to save energy of a smartphone for example), just place some “random” Thread sleeps in there.

Your construct to run your logic at fixed time steps shouldn’t depend on thread sleep calls, because they can be quite inaccurate like you noticed.

How does something like this look?



long startTime = System.currentmilliseconds();
long elapsedTicks;
int ticksPerSecond = 40;
int timePerTick = 1000 / ticksPerSecond ;
while(running)
{
   long time = System.currentmilliseconds();
   int newTicks = (time - startTime) / timePerTick - elapsedTicks;

   for(int i=0; i < newTicks; ++i)
      doLogicForTick();

   elapsedTicks += newTicks;
   
   render();

   //here you could put some code that if the framerate is going to high you put in some thread sleeps
}
#5

Yes a busy loop works very well but just letting things go on and on is bad as you use too much cpu when you don’t need to. Think of mobile devices with power consumption.

If you use lwjgl then there is a very nice convenience method there to sync stuff.
There are also so very nice game loop tutorials here if anyone wants to try the search engine.

#6

I just like to say that no-fps cap has not only to do with power comsuption and mobile devices. apart form delta programming being awful, I will delete every game that runs max FPS immediately.
It will heat up the GPU for no reason and put stress on the system.

I have a open case, and I can actually HEAR the GPU getting overstressed if you do that; its like a high pitched quiet beep.

Also fixed framerate ftw.

#7

@OP
Windows has a very inaccurate sleep timer, which is why you are noticing those terrible timings. Check out my game loop along with a very accurate sleep trick.

#8

I tried to combine an underestimed sleep with a busy loop to wait the last few ms precisely. I.e. I used a sleep with 5ms less than the total sleep time, and waited the remaining time in a busy loop. That was quiet precise and somewhat multi-process friendly.

#9

Yes, I don’t like games running on max FPS too, because my cpu or graphics chip could get really hot, and this reduces the life time of them.

Anyways: Here is my implementation, which is not as simple as ra4king’s implementation, but with Listeners and with Rivens super-duper accurate Sleep syncing. It’s hosted on GitHub and needs only the files in the “org.matheusdev.util.gameloop” package. See the package here: https://github.com/matheus23/Utils/tree/master/Utils/src/org/matheusdev/util/gameloop

It allows you different techneques:
[x] A “frame-skipper”, which skips rendering, if there is enough time left, since it would only be redunant rendering time (but this version consumes 100% cpu),
[x] a delta-based rendering loop, which only renders and ticks your game as much as needed and even handles the computation of the delta-time, which is simply a double, which is 1, when you currently render at 60 fps, and lower, if the framerate is higher, or higher, if the framerate is lower. For example, in case your game renders at 120 fps, the delta would be 0.5. Also, it is flexible, which means it updates every frame.
[x] And the last techneque is a “no-tech”, which does just no frame skipping, and no sleeping at all. It just renders at highest framerate.

And at the very last: All versions include an accurate FPS counter, which is just given to you as an int.