public void loop() {
   Date startTime = new Date();
   Date previousRepaint = startTime;
   Date currentTime = startTime;
   float delta;
   float redrawsPerSecond = 1000/maxFps;
   
   // While the game is not over...
   while(!gameOver) {
      currentTime = new Date();
      delta = currentTime.getTime()-previousRepaint.getTime();
      
      update(delta);
      repaint();
      
      previousRepaint = currentTime;
      
      // Limit repaint to the max FPS.
      if(delta <= redrawsPerSecond) {
         try { Thread.sleep(10); } catch(Exception e) { /* pass */ }
      }
   }
}

   long startTime = System.getCurrentMillis(); //can be System.nanoTime() if you need higher precision

final long LOOPTIME = 1000/60; //for 60 FPS in 1000ms
long nextLoop;

while(true) {
    nextLoop = System.currentTimeMillis() + LOOPTIME;

    //do logic and repaint stuff

    while(System.currentTimeMillis() < nextLoop) {
        Thread.yield();
    }
}

public class GameFrame extends JFrame{
  
  public static int TIME_DELAY = 10;
  GamePanel gPanel;
  Timer timer = new Timer(TIME_DELAY, TimerListener);
  
  class TimerListener implements ActionListener{
    
    public void actionPerformed(ActionEvent e){
      gPanel.repaint();
    }
  }
}

public class GamePanel extens JPanel{
  
  GameFrame gameFrame;
  
  protected void paintComponent(Graphics g) {
    long time0 = System.nanotime();
    //The code of the game loop
    //....
    //end of the game loop
    long time1 = System.nanotime();
    int t10 = (int)(time1-time0)/1000000;
    int timeDelay = setTimeDelay(t10);
    //+2 because it's the average time difference between 2 repaint and
    //the time in the game loop
    gameFrame.TIME_DELAY = timeDelay + 2; 
    gameFrame.timer.setDelay(timeDelay);    
  }
  
  private int setTimeDelay(int time){
    listTimeDelay.addFirst(time);
    if(listTimeDelay.size() > 10){
      listTimeDelay.removeLast();
    }
    int retour = 0;
    for(int i=0; i<listTimeDelay.size(); i++){
      retour += listTimeDelay.get(i);
    }
    if(listTimeDelay.size() > 0){
      retour = retour/listTimeDelay.size();
    }
    //13+2 is my maximum repaint() speed
    if(retour < 13){
      retour = 13;
      //Too big value mess up with the physics
    }else if(retour > 30){
      retour = 30;
    }
    return retour;
  }
}

public class GameLoop implements Runnable{
    
    long desiredFPS = 60;
    long desiredDeltaLoop = (1000*1000*1000)/desiredFPS;
    
    long beginLoopTime;
    long endLoopTime;
    long currentPhysicTime;
    long lastPhysicTime;
    
    boolean running = true;
    
    public void run(){
        
        loopInitialization();
        
        while(running){
            beginLoopTime = System.nanoTime();
            executeDrawing();
            
            lastPhysicTime = currentPhysicTime;
            currentPhysicTime = System.nanoTime();
            executePhysic(currentPhysicTime - lastPhysicTime);
            
            executeLogic();
            
            endLoopTime = System.nanoTime();
            adjustSpeed();
        }
        
    }
    
    private void adjustSpeed(){
        long deltaLoop = endLoopTime - beginLoopTime;
        
        if(deltaLoop > desiredDeltaLoop){
            //Do nothing. We are alreadyLate
        }else{
            try{
                Thread.sleep((desiredDeltaLoop - deltaLoop)/(1000*1000));
            }catch(InterruptedException e){
                //Do nothing
            }
        }
    }
    
    private void loopInitialization(){
        currentPhysicTime = System.nanoTime();
    }
    
    private void executeDrawing(){
        //Do the drawing here
    }
    
    private void executePhysic(long deltaPhysic){
        //Do the physic here
    }
    
    private void executeLogic(){
        //Do the logic here
    }

//http://www.java-gaming.org/topics/how-can-i-make-this-simple-game-loop-better/19971/view.html

import java.util.*;

import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferStrategy;

import java.awt.DisplayMode; // for full-screen mode

public class GameLoop1 implements KeyListener {
    Frame mainFrame;

    private static final long NANO_IN_MILLI = 1000000L;   
    long desiredFPS = 60;
    long desiredDeltaLoop = (1000*1000*1000)/desiredFPS;    

    long beginLoopTime;
    long endLoopTime;
    long currentPhysicTime;
    long lastPhysicTime;

    long fps;
    long frameCounter;
    long lastFpsTime;
    
    Rectangle2D rect;
    
    public GameLoop1(Map<String,String> args, GraphicsDevice device) {
        try {
            // Setup the frame
            GraphicsConfiguration gc = device.getDefaultConfiguration();
            
            mainFrame = new Frame(gc);
            mainFrame.setUndecorated(true);
            mainFrame.setIgnoreRepaint(true);
            mainFrame.setVisible(true);
            mainFrame.setSize(640, 480);
            //mainFrame.setLocationRelativeTo();
            mainFrame.setLocation(100,100);
            mainFrame.createBufferStrategy(2);
            mainFrame.addKeyListener(this);

            if ("true".equalsIgnoreCase(args.get("fullscreen"))) {
              device.setFullScreenWindow(mainFrame);
              device.setDisplayMode(new DisplayMode(640, 480, 8, DisplayMode.REFRESH_RATE_UNKNOWN));
            }
          
            // Cache the buffer strategy and create a rectangle to move
            BufferStrategy bufferStrategy = mainFrame.getBufferStrategy();
            rect = new Rectangle2D.Float(0,100,64,64);
            
            // loop initialization
            currentPhysicTime = System.nanoTime();
            lastFpsTime = currentPhysicTime;

            // Main loop
            while(true) {
                beginLoopTime = System.nanoTime();

                // Synchronise with the display hardware. Note that on
                // Windows Vista this method may cause your screen to flash.
                // If that bothers you, just comment it out.
                //Toolkit.getDefaultToolkit().sync();
            
                // **1) execute drawing
                Graphics g = bufferStrategy.getDrawGraphics();
                drawScreen(g);
                g.dispose();

                // Flip the buffer
                if( !bufferStrategy.contentsLost() )
                    bufferStrategy.show();
                
                // **2) execute physics
                lastPhysicTime = currentPhysicTime;
                currentPhysicTime = System.nanoTime();
                updateWorld(currentPhysicTime - lastPhysicTime);               
            
                calculateFramesPerSecond();
            
                // **3) execute logic
                // executeLogic(); // handle keyboard and other inputs
                endLoopTime = System.nanoTime();
                adjustSpeed();            
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            device.setFullScreenWindow(null);
        }
    }
   
    private void adjustSpeed() {
        long deltaLoop = endLoopTime - beginLoopTime;
        
        if(deltaLoop > desiredDeltaLoop) {
            // do nothing. We are alreadyLate
            System.out.println("Late, do not sleep");
        } else {
            try {
                Thread.sleep((desiredDeltaLoop - deltaLoop) / NANO_IN_MILLI);
            } catch (InterruptedException ex) { }
        }
    }   

    private void updateWorld(long elapsedTime) {
        // speed: 150 pixels per second
        double xMov = (140f/(NANO_IN_MILLI*1000)) * elapsedTime;
        //double xMov = 2.0;
        rect.setRect(rect.getX() + xMov, 100, 64, 64);
        
        if( rect.getX() > mainFrame.getWidth() )
            rect.setRect(-rect.getWidth(), 100, 64, 64);
    }
    
    private void drawScreen(Graphics g) {
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, mainFrame.getWidth(), mainFrame.getHeight());
        g.setColor(Color.WHITE);
        g.drawString("FPS: " + fps, 0, 17);
        
        g.setColor(Color.RED);
        g.fillRect((int)rect.getX(), (int)rect.getY(), (int)rect.getWidth(), (int)rect.getHeight());
    }
    
    private void calculateFramesPerSecond() {
        if( currentPhysicTime - lastFpsTime >= NANO_IN_MILLI*1000 ) {
            fps = frameCounter;
            frameCounter = 0;
            lastFpsTime = currentPhysicTime;
        }
        frameCounter++;
    }
   
    public void keyPressed(KeyEvent e) {
        if( e.getKeyCode() == KeyEvent.VK_ESCAPE ) {
            System.exit(0);
        }
    }
   
    public void keyReleased(KeyEvent e) { }
    public void keyTyped(KeyEvent e) { }

    public static void main(String[] args) {
        try {
       Map<String,String> mapArgs = parseArguments(args);

            GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
            GraphicsDevice device = env.getDefaultScreenDevice();
            new GameLoop1(mapArgs, device);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }


   /**
    * Parse commandline arguments, each parameter is a name-value pair.
    * Example: java.exe MyApp "key1=value1" "key2=value2"
    */
   private static Map<String,String> parseArguments(String[] args) {
      Map<String,String> mapArgs = new HashMap<String,String>();

      for(int idx=0; idx < args.length; idx++) {
         String val = args[idx];
         int delimIdx = val.indexOf('=');
         if (delimIdx < 0) {
            mapArgs.put(val, null);
         } else if (delimIdx == 0) {
            mapArgs.put("", val.substring(1));
         } else {
            mapArgs.put(
               val.substring(0, delimIdx).trim(),
               val.substring(delimIdx+1)
            );
         }
      }
      
      return mapArgs;
   }

}

// java GameLoop2 "fullscreen=true" "fps=60" "vsync=false"
//http://www.java-gaming.org/topics/how-can-i-make-this-simple-game-loop-better/19971/view.html

import java.util.*;

import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferStrategy;

import java.awt.DisplayMode; // for full-screen mode

// java GameLoop2 "fullscreen=true" "fps=60" "vsync=false"
public class GameLoop2 implements KeyListener {
    Frame mainFrame;

    private static final long NANO_IN_MILLI = 1000000L;   

    // num of iterations with a sleep delay of 0ms before
    // game loop yields to other threads.
    private static final int NO_DELAYS_PER_YIELD = 16;

    // max num of renderings that can be skipped in one game loop,
    // game's internal state is updated but not rendered on screen.
    private static int MAX_RENDER_SKIPS = 5;

    private static int TARGET_FPS = 60;
   
    //private long prevStatsTime;
    private long gameStartTime;
    private long curRenderTime;
    private long rendersSkipped = 0L;
    private long period; // period between rendering in nanosecs

    long fps;
    long frameCounter;
    long lastFpsTime;
    
    Rectangle2D rect;
    
    public GameLoop2(Map<String,String> args, GraphicsDevice device) {
        try {
            if (args.containsKey("fps"))
              TARGET_FPS = Integer.parseInt(args.get("fps"));


            // Setup the frame
            GraphicsConfiguration gc = device.getDefaultConfiguration();
            
            mainFrame = new Frame(gc);
            mainFrame.setUndecorated(true);
            mainFrame.setIgnoreRepaint(true);
            mainFrame.setVisible(true);
            mainFrame.setSize(640, 480);
            //mainFrame.setLocationRelativeTo();
            mainFrame.setLocation(100,100);
            mainFrame.createBufferStrategy(2);
            mainFrame.addKeyListener(this);

            if ("true".equalsIgnoreCase(args.get("fullscreen"))) {
              device.setFullScreenWindow(mainFrame);
              device.setDisplayMode(new DisplayMode(640, 480, 8, DisplayMode.REFRESH_RATE_UNKNOWN));
            }
          
            final boolean VSYNC = "true".equalsIgnoreCase(args.get("vsync"));

            // Cache the buffer strategy and create a rectangle to move
            BufferStrategy bufferStrategy = mainFrame.getBufferStrategy();
            rect = new Rectangle2D.Float(0,100,64,64);

            // loop initialization
            long beforeTime, afterTime, timeDiff, sleepTime;
            long overSleepTime = 0L;
            int noDelays = 0;
            long excess = 0L;
            gameStartTime = System.nanoTime();
            //prevStatsTime = gameStartTime;
            beforeTime = gameStartTime;
      
            period = (1000L*NANO_IN_MILLI)/TARGET_FPS;  // rendering FPS (nanosecs/targetFPS)
            System.out.println("FPS: " + TARGET_FPS + ", vsync=" + VSYNC);
            System.out.println("FPS period: " + period);
            

            // Main loop
            while(true) {
               // **2) execute physics
               updateWorld(0);               

               // **1) execute drawing
               Graphics g = bufferStrategy.getDrawGraphics();
               drawScreen(g);
               g.dispose();

               // Synchronise with the display hardware. Note that on
               // Windows Vista this method may cause your screen to flash.
               // If that bothers you, just comment it out.
               if (VSYNC) Toolkit.getDefaultToolkit().sync();

               // Flip the buffer
               if( !bufferStrategy.contentsLost() )
                   bufferStrategy.show();

               afterTime = System.nanoTime();
               curRenderTime = afterTime;
               calculateFramesPerSecond();

               timeDiff = afterTime - beforeTime;
               sleepTime = (period-timeDiff) - overSleepTime;
               if (sleepTime > 0) { // time left in cycle
                  //System.out.println("sleepTime: " + (sleepTime/NANO_IN_MILLI));
                  try {
                     Thread.sleep(sleepTime/NANO_IN_MILLI);//nano->ms
                  } catch(InterruptedException ex){}
                  overSleepTime = (System.nanoTime()-afterTime) - sleepTime;
               } else { // sleepTime <= 0;
                  System.out.println("Rendering too slow");
                  // this cycle took longer than period
                  excess -= sleepTime;
                  // store excess time value
                  overSleepTime = 0L;
                  if (++noDelays >= NO_DELAYS_PER_YIELD) {
                     Thread.yield();
                     // give another thread a chance to run
                     noDelays = 0;
                  }
               }
            
               beforeTime = System.nanoTime();
         
               //If the rendering is taking too long, then
               //update the game state without rendering
               //it, to get the UPS nearer to the required frame rate. 
               int skips = 0;
               while((excess > period) && (skips < MAX_RENDER_SKIPS)) {
                  // update state but don’t render
                  System.out.println("Skip renderFPS, run updateFPS");
                  excess -= period;
                  updateWorld(0);
                  skips++;
               }
               rendersSkipped += skips;
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            device.setFullScreenWindow(null);
        }
    }

    private void updateWorld(long elapsedTime) {
        // speed: 150 pixels per second
        //double xMov = (140f/(NANO_IN_MILLI*1000)) * elapsedTime;
        double xMov = 140f / (TARGET_FPS);
        rect.setRect(rect.getX()+xMov, 100, 64, 64);        
        if( rect.getX() > mainFrame.getWidth() )
            rect.setRect(-rect.getWidth(), 100, 64, 64);
    }
    
    private void drawScreen(Graphics g) {
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, mainFrame.getWidth(), mainFrame.getHeight());
        g.setColor(Color.WHITE);
        g.drawString("FPS: " + fps, 0, 17);
        
        g.setColor(Color.RED);
        g.fillRect((int)rect.getX(), (int)rect.getY(), (int)rect.getWidth(), (int)rect.getHeight());
    }
    
    private void calculateFramesPerSecond() {
        if( curRenderTime - lastFpsTime >= NANO_IN_MILLI*1000 ) {
            fps = frameCounter;
            frameCounter = 0;
            lastFpsTime = curRenderTime;
        }
        frameCounter++;
    }
   
    public void keyPressed(KeyEvent e) {
        if( e.getKeyCode() == KeyEvent.VK_ESCAPE ) {
            System.exit(0);
        }
    }
   
    public void keyReleased(KeyEvent e) { }
    public void keyTyped(KeyEvent e) { }

    public static void main(String[] args) {
        try {
       Map<String,String> mapArgs = parseArguments(args);

            GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
            GraphicsDevice device = env.getDefaultScreenDevice();
            new GameLoop2(mapArgs, device);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }


   /**
    * Parse commandline arguments, each parameter is a name-value pair.
    * Example: java.exe MyApp "key1=value1" "key2=value2"
    */
   private static Map<String,String> parseArguments(String[] args) {
      Map<String,String> mapArgs = new HashMap<String,String>();

      for(int idx=0; idx < args.length; idx++) {
         String val = args[idx];
         int delimIdx = val.indexOf('=');
         if (delimIdx < 0) {
            mapArgs.put(val, null);
         } else if (delimIdx == 0) {
            mapArgs.put("", val.substring(1));
         } else {
            mapArgs.put(
               val.substring(0, delimIdx).trim(),
               val.substring(delimIdx+1)
            );
         }
      }
      
      return mapArgs;
   }

}

private static final long NANO_IN_MILLI = 1000000L;
   private static int MAX_RENDER_SKIPS = 5;
   private static int TARGET_FPS = 60;
   
   boolean running = true;
   long period = (1000L*NANO_IN_MILLI)/TARGET_FPS;
   
   public void run(){

      long beforeTime = System.nanoTime();
      long afterTime, timeDiff, sleepTime;
      long excess = 0L;

      while(running){
         update();
         
         render();
         
         afterTime = System.nanoTime();
         timeDiff = afterTime - beforeTime;
         sleepTime = (period-timeDiff) - excess;
         if (sleepTime > 0) { // time left in cycle
            //System.out.println("sleepTime: " + (sleepTime/NANO_IN_MILLI));
            try {
               Thread.sleep(sleepTime/NANO_IN_MILLI);//nano->ms
            } catch(InterruptedException ex){}
            excess = (System.nanoTime()-afterTime) - sleepTime;
         } else { // sleepTime <= 0;
            System.out.println("Rendering too slow");
            // this cycle took longer than period
            excess -= sleepTime;
         }

         beforeTime = System.nanoTime();

         /* If the rendering is taking too long, then
                update the game state without rendering
                it, to get the UPS nearer to the
                required frame rate. */
         int skips = 0;
         while((excess > period) && (skips < MAX_RENDER_SKIPS)) {
            // update state but don’t render
            System.out.println("Skip renderFPS, run updateFPS");
            excess -= period;
            update();
            skips++;
         }
      }
   }
   
   private void render(){
      //Not implemented
   }
   
   private void update(){
      //Not implemented
   }

public class ExampleLoopNew {
   
   boolean running = true;
   
   public void run(){
      
      long loopBeginTime = System.currentTimeMillis();
      long loopTimeLapse;
      
      while(running){
         
         loopTimeLapse = System.currentTimeMillis() - loopBeginTime;
         loopBeginTime = System.currentTimeMillis();
         
         render();
         
         long sleep = (loopBeginTime+31) - System.currentTimeMillis();
         // System.out.println(sleep);   // check to make sure never negative
         try { Thread.sleep(sleep); } catch (Exception e) {}
      }
   }
   
   private void render(){
      //Not implement
   }

}

public class ExampleLoopMine {
   
   long desiredFPS = 60;
    long desiredDeltaLoop = (1000*1000*1000)/desiredFPS;
    
   boolean running = true;
   
   public void run(){
      
      long beginLoopTime;
      long endLoopTime;
      long currentUpdateTime = System.nanoTime();
      long lastUpdateTime;
      long deltaLoop;
      
      while(running){
         beginLoopTime = System.nanoTime();
         
         render();
         
         lastUpdateTime = currentUpdateTime;
         currentUpdateTime = System.nanoTime();
         update(currentUpdateTime - lastUpdateTime);
         
         endLoopTime = System.nanoTime();
         deltaLoop = endLoopTime - beginLoopTime;
           
           if(deltaLoop > desiredDeltaLoop){
               //Do nothing. We are already late
           }else{
               try{
                   Thread.sleep((desiredDeltaLoop - deltaLoop)/(1000*1000));
               }catch(InterruptedException e){
                   //Do nothing
               }
           }
      }
   }
   
   private void render(){
      //Not implemented
   }
   
   private void update(long deltaTime){
      //Not implemented
   }

}