Java - eine while-Schleife (in Therad) verursacht hohe CPU nur auf Mac

Question

Ich brauche Hilfe,

Ich habe diesen Code, aus einem Tutorial von Java-Spiele-Entwicklung,
Wenn ich den Code ausführen, die while-Schleife (Der Thread) gibt meinem Macbook eine hohe CPU.

ich diesen Code auf Ubuntu vm ausgeführt habe und auf Windows 7 - sowohl die CPU war niedrig und normal,
wenn es los - die Fäden lagen bei rund 27 - (Im Task-Manager/in Activity Monitor/im System Monitor).

Mac - CPU wird hoch nur auf meinem Mac jetzt 89,7, manchmal mehr als 100:

Ubuntu - CPU niedrig ist etwa 2:

BITTE,

Ich weiß, dass ich das mit Schlaf beheben kann:

thread.sleep(5); 

Aber warum funktioniert es gut auf anderen Betriebssystemen? Windows .. Linux .. Ich habe diesen Code auch auf anderen Macbook Air getestet. Auf der anderen Mac war es hoch zu.

Einige Informationen über mein Problem:

• Ich bin mit Mac OSX 10.11.5

• Java-Version:

  java version "1.8.0_91" 
  Java(TM) SE Runtime Environment (build 1.8.0_91-b14) 
  Java HotSpot(TM) 64-Bit Server VM (build 25.91-b14, mixed mode) 
  

• Code:

Renderer Klasse:

package org.graphics; 

import org.game.Game; 

import java.awt.*; 
import java.awt.event.WindowAdapter; 
import java.awt.event.WindowEvent; 
import java.awt.image.VolatileImage; 

public class Renderer { 

    private static Frame frame; 
    private static Canvas canvas; 

    private static int canvasWidth = 0; 
    private static int canvasHeight = 0; 

    private static final int GAME_WIDTH = 400; 
    private static final int GAME_HEIGHT = 250; 

    private static int gameWidth = 0; 
    private static int gameHeight = 0; 


    private static void getBestSize() { 
     Toolkit toolkit = Toolkit.getDefaultToolkit(); 
     Dimension screenSize = toolkit.getScreenSize(); 

     boolean done = false; 

     while (!done) { 
      canvasWidth += GAME_WIDTH; 
      canvasHeight += GAME_HEIGHT; 

      if (canvasWidth > screenSize.width || canvasHeight > screenSize.height) { 
       canvasWidth -= GAME_WIDTH; 
       canvasHeight -= GAME_HEIGHT; 

       done = true; 
      } 

     } 

     int XDiff = screenSize.width - canvasWidth; 
     int YDiff = screenSize.height - canvasHeight; 
     int factor = canvasWidth/GAME_WIDTH; 

     gameWidth = canvasWidth/factor + XDiff/factor; 
     gameHeight = canvasHeight/factor + YDiff/factor; 

     canvasWidth = gameWidth * factor; 
     canvasHeight = gameHeight * factor; 

    } 

    private static void makeFullScreen() { 
     GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment(); 
     GraphicsDevice gd = env.getDefaultScreenDevice(); 

     if (gd.isFullScreenSupported()) { 
      frame.setUndecorated(true); 
      gd.setFullScreenWindow(frame); 
     } 
    } 

    public static void init() { 
     getBestSize(); 

     frame = new Frame(); 
     canvas = new Canvas(); 

     canvas.setPreferredSize(new Dimension(canvasWidth, canvasHeight)); 

     frame.add(canvas); 

     makeFullScreen(); 

     frame.pack(); 
     frame.setResizable(false); 
     frame.setLocationRelativeTo(null); 


     frame.addWindowListener(new WindowAdapter() { 

      public void windowClosing(WindowEvent e) { 
       Game.quit(); 
      } 


     }); 

     frame.setVisible(true); 

     startRendering(); 

    } 

    private static void startRendering() { 
     Thread thread = new Thread() { 
      public void run() { 

       GraphicsConfiguration gc = canvas.getGraphicsConfiguration(); 
       VolatileImage vImage = gc.createCompatibleVolatileImage(gameWidth, gameHeight); 

       while (true) { 
        if (vImage.validate(gc) == VolatileImage.IMAGE_INCOMPATIBLE) { 
         vImage = gc.createCompatibleVolatileImage(gameWidth, gameHeight); 
        } 

        Graphics g = vImage.getGraphics(); 

        //Start// 

        g.setColor(Color.black); 
        g.fillRect(0, 0, gameWidth, gameHeight); 

        //end// 

        g.dispose(); 

        g = canvas.getGraphics(); 
        g.drawImage(vImage, 0, 0, canvasWidth, canvasHeight, null); 

        g.dispose(); 


       } 
      } 
     }; 
     thread.setName("Render Thread"); 
     thread.start(); 
    } 
} 

Spielklasse:

package org.game; 

import org.graphics.Renderer; 

public class Game { 

    public static void main(String args[]){ 
     Renderer.init(); 
    } 

    public static void quit(){ 
     System.exit(0); 
    } 
} 

Answer 1

Ich bin der Typ, der dieses Tutorial erstellt. Ich denke ich sehe was das Problem ist. Als Sie mich vor der Frage nach meiner CPU gefragt haben, habe ich den CPU-Zähler im unteren Bereich des Aktivitätsmonitorfensters und nicht den für diesen bestimmten Prozess überprüft. Mein Missverständnis.

Der Grund, warum es so hoch ist, ist, dass wir noch keine Art von Schlaf implementiert haben. Ich plane das später in einer Episode über die Steuerung von Bildern pro Sekunde. Bis dahin ist es normal, dass der CPU-Anteil hoch ist. Beachten Sie, dass der Gesamtprozentsatz der verfügbaren CPU von der Anzahl der Kerne in Ihrem Computer abhängt. In Ihrem Fall verwendet das Programm 89,7% eines Ihrer CPU-Kerne.

Vielen Dank für das Stellen dieser Frage.

EDIT: Der Grund, warum es so hoch ist, ist, weil, da wir es nicht schlafen lassen, es die Schleife so schnell wie möglich ausführen wird, was die totale (oder fast vollständige) Verwendung von einem ergibt der CPU-Kerne.