public static final void sleep(long ms)
   {
      sleep(ms, true);
   }

   public static final void sleep(long ms, boolean consumeInterrupts)
   {
      final long end = (System.nanoTime()/1000000L) + ms;

      while ((System.nanoTime()/1000000L) < end)
      {
         try
         {
            long togo = end - (System.nanoTime()/1000000L);

            // ensure we don't suffer from OS 'sleep-snapping'
            long sleep = togo / 2 + 1;

            if (sleep > 0)
               Thread.sleep(sleep);
         }
         catch (InterruptedException exc)
         {
            if (consumeInterrupts)
            {
               Thread.currentThread().interrupt();
               Thread.interrupted();
            }
            else
            {
               return;
            }
         }
      }
   }

package cg.puzzlecarnival;
import cg.main.Time;
import cg.puzzlecarnival.gui.GuiAccess;

/**This class executes the main loop.
 * @author Steven Fletcher
 * @since 2007/08/14
 * @version 2008/02/21
 */
public class MainLoop {
/**Executes the game's main loop.*/
public static void execute() {
   //This variable is used to only skip yielding a certain number of times in a row.
   byte numDelays = 0;
   
   //This variable stores how much time the loop overslept by in the last cycle.
   //Negative values probably won't occur because Thread.sleep shouldn't undersleep.
   long overSleepTime = 0L;
   
   //This variable is used for computing the length of an update phase.
   long lastUpdatePhase = Time.currentTimeMillis();

   while(true) {
      //if the application isn't visible, sleep for half a second
      if(!GuiAccess.isApplicationActive()) {
         try {
            Thread.sleep(500);
         } catch(InterruptedException exception) {}
            
         continue;
      } //end if the frame isn't visible
      
      //figure out the start of the current phase
      long currentCycle = Time.currentTimeMillis();
      long updatePhaseLength = currentCycle - lastUpdatePhase;
      if(updatePhaseLength > period)
         updatePhaseLength = period;
      
      //update the current model
      GuiAccess.updateLogic(period);
      lastUpdatePhase = Time.currentTimeMillis();
   
      //render the game
      GuiAccess.showFrame();
   
      //figure out how long the cycle took
      long timeAfterCycle = Time.currentTimeMillis();
      long cycleLength = timeAfterCycle - currentCycle;
      long sleepTime = period - cycleLength - overSleepTime;
      
      //if some time is left in this cycle
      if(sleepTime > 0) {
         //sleep
         try {
            Thread.sleep(sleepTime);
         } catch(InterruptedException exception) {}
         
         overSleepTime = Time.currentTimeMillis() - timeAfterCycle - sleepTime;
      } //end if some time is left in this cycle
      //else no time is left in this cycle
      else {
         overSleepTime = 0L;
         
         //don't sleep, but yield if absolutely necessary
         numDelays++;
         if(numDelays >= maximumDelaysPerYield) {
            //yield to let other threads execute
            Thread.yield();
            numDelays = 0;
         } //end if there have been too many delays
      } //end else no time is left in this cycle
} //end while forever
} //end execute

//PRIVATE CONSTANTS//////////////////////////////////////////////////////////////////////
//the maximum number of consecutive cycles that can skip the yield
private static final int maximumDelaysPerYield = 16;

//private static final int maximumMillisecondsPerUpdate = 40;
//private static final int millisecondsPerFrameRedraw = 10;

//1000/period frames per second
private static final int period = 40;
} //end class MainLoop