What is causing this Graphics2D rendering stutter/lag

Question

Mouse.java

package game.input;

import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseWheelEvent;

// holds information about mouse events.
// eg, presses of buttons.
public class Mouse extends MouseAdapter {
    // the position of the mouse.
    public static int x, y;
    
    // Is the mouse pressed.
    public static boolean pressed;
    
    // Is the mouse held.
    public static boolean held;
    
    // Is the mouse hovered over the window.
    public static boolean focused;
    
    // Is the mouse being dragged.
    public static boolean dragging;
    
    // no mouse wheel support.
    @Override
    public void mouseWheelMoved(MouseWheelEvent event) {}
    
    @Override
    public void mouseDragged(MouseEvent event) {
        x = event.getX();
        y = event.getY();
        dragging = true;
    }
    
    @Override
    public void mouseMoved(MouseEvent event) {
        x = event.getX();
        y = event.getY();
    }
    
    @Override
    public void mouseEntered(MouseEvent event) {
        focused = true;
    }
    
    @Override
    public void mouseExited(MouseEvent event) {
        focused = false;
    }
    
    @Override
    public void mousePressed(MouseEvent event) {
        held = true;
    }
    
    @Override
    public void mouseReleased(MouseEvent event) {
        held = false;
        dragging = false;
        pressed = true;
    }
}

Keyboard.java

package game.input;

import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

// holds information about key events.
public class Keyboard extends KeyAdapter {
    // which keys are being held down.
    private static boolean[] heldKeys;
    
    // which keys are being clicked
    private static boolean[] clickedKeys;
    
    // size of arrays.
    private final int size;
    
    public Keyboard() {
        // there are 255 valid key codes.
        // plus one for the array size.
        size = 256;
        
        clickedKeys = new boolean[size];
        heldKeys = new boolean[size];
    }
    
    // when the key is pressed.
    @Override
    public void keyPressed(KeyEvent event) {
        // catches out of bounds error.
        if(event.getKeyCode() > size)
            return;
        
        // key is being held.
        heldKeys[event.getKeyCode()] = true;
    }
    
    @Override
    public void keyReleased(KeyEvent event) {
        // catches out of bounds error.
        if(event.getKeyCode() > size)
            return;
        
        // key is let go.
        heldKeys[event.getKeyCode()] = false;
        
        // when key is let go, it gets interpreted as it being pressed.
        clickedKeys[event.getKeyCode()] = true;
    }
    
    // returns whether or not the key is held.
    public static boolean keyHeld(Key key) {
        if(heldKeys != null)
            return heldKeys[key.keyCode];
        return false;
    }
    
    // returns whether or not the key is clicked.
    public static boolean keyClicked(Key key) {
        if(clickedKeys != null)
            return clickedKeys[key.keyCode];
        return false;
    }
    
    // resets key input.
    public static void resetKeys() {
        if(clickedKeys != null)
            for(int i = 0; i < clickedKeys.length; i++)
                clickedKeys[i] = false;
    }
    
    public enum Key {
        // movement keys.
        LEFT(37), UP(38), RIGHT(39), DOWN(40),
        
        // x key.
        A(88),
        
        // z key.
        B(90),
        
        // enter key.
        START(10);
        
        private int keyCode;
        
        private Key(int keyCode) {
            this.keyCode = keyCode;
        }
    };
}

Game.java

package game;

import java.awt.Graphics2D;

import game.input.Keyboard;
import game.input.Mouse;
import game.room.Room;
import userInterface.containers.BB_Window;

// creates a new game
public final class Game {
    // the window that the game resides in.
    private static BB_Window window;
    
    // the current room that is drawn to the window.
    private static Room room;
    
    private static GameLoop gameLoop;
    
    // game constructor cannot be called.
    private Game() {}
    
    // inits the game.
    // ie, adds input to the game (key and mouse).
    public static void init(BB_Window window) {
        if(gameLoop != null)
            return;
        
        // creates mouse and keyboard listeners.
        Mouse mouse = new Mouse();
        Keyboard keyboard = new Keyboard();
        
        // adds input listeners to the window.
        window.getJFrame().addKeyListener(keyboard);
        window.getCanvas().addMouseListener(mouse);
        window.getCanvas().addMouseMotionListener(mouse);
        
        // init game loop
        gameLoop = new GameLoop();
        
        // init window
        Game.window = window;
        
        gameLoop.start();
    }
    
    // updates the current room and resets input.
    protected static void update() {
        // if room doesn't exist, don't update it.
        if(room == null)
            return;
        
        // updates current room.
        Game.room.update();
        
        // resets mouse input.
        Mouse.pressed = false;
        
        // resets key input.
        Keyboard.resetKeys();
        
        // if a mouse or key button is clicked,
        // then it would have to be reset to false here.
    }
    
    // renders the current room.
    protected static void render() {
        // if room doesn't exist, don't render it.
        if(room == null)
            return;
        
        // creates graphics object from the window canvas.
        Graphics2D graphics = (Graphics2D) window.getCanvas().getBufferStrategy().getDrawGraphics();
        
        // creates the screen for next drawing.
        graphics.clearRect(0, 0, window.getWidth(), window.getHeight());
        
        // renders the current room.
        Game.room.render(graphics);
        
        // shows the buffer.
        window.getCanvas().getBufferStrategy().show();
        
        // removes graphics object.
        graphics.dispose();
    }
    
    // sets the current room to a new one.
    public static void setRoom(Room newRoom) {
        newRoom.init();
        Game.room = newRoom;
    }
    
    // returns the current room.
    public static Room getRoom() {
        return Game.room;
    }
    
    // returns width of window.
    public static int getWindowWidth() {
        return window.getWidth();
    }
    
    // returns height of window.
    public static int getWindowHeight() {
        return window.getHeight();
    }
    
    // stops the game loop.
    public static void stop() {
        gameLoop.stop();
    }
}

GameLoop.java

package game;

public class GameLoop implements Runnable {
    // the thread that the game runs on.
    private Thread thread;
    
    // is the game running.
    private boolean running;
    
    // starts the game loop.
    // inits the thread and calls its start method.
    public void start() {
        // you can't start the game if it is started.
        if(running)
            return;
        
        // starts the game.
        running = true;
        
        // creates thread.
        thread = new Thread(this);
        
        // starts the game.
        // ie, calls thread.run();
        thread.start();
    }
    
    // stops the game loop.
    // interrupts the thread and terminates the currently running JVM.
    public void stop() {
        // you can't end the game if it is ended.
        if(!running)
            return;
        
        // ends the game.
        running = false;
        
        // interrupts the thread.
        // ie, ends the thread.
        // this will always end the thread,
        // because running is set to false.
        thread.interrupt();
        
        // ends the program.
        System.exit(0);
    }
    
    // this is the game loop.
    @Override
    public void run() {
        // holds information about each frames elapsed time.
        double start, previous = System.nanoTime() / 1_000_000_000.0;
        
        // time.
        double actualFrameTime, realTime = 0;
        
        // should the game be rendered.
        boolean render;
        
        // fps
        final int FPS = 60;
        final double DESIRED_FRAME_TIME = 1.0 / FPS;
        
        // while the game is running
        while(running) {
            // calculates the elapsed time of the frame.
            // converts from nano seconds to seconds
            // by dividing by one billion.
            start = System.nanoTime() / 1_000_000_000.0;
            actualFrameTime = start - previous;
            previous = start;
            
            // the game time is updated by the elapsed frame time.
            realTime += actualFrameTime;
            
            // resets it to back to false.
            render = false;
            
            // if time surpasses desired frame time, game should update.
            while(realTime >= DESIRED_FRAME_TIME && realTime != 0) {
                realTime -= DESIRED_FRAME_TIME;
                Game.update();
                
                // if the game is updated, the game should render.
                // if the game is not updated, the game doesn't render.
                render = true;
            }
            
            if(render)
                Game.render();
            // sleep if game should not render.
            // reduces cpu usage by a lot.
            else
                try {
                    // sleep for one millisecond.
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }
    }
}

BB_Window.java

package userInterface.containers;

import java.awt.Canvas;
import java.awt.Dimension;
import java.awt.image.BufferStrategy;

import javax.swing.JFrame;

// the JFrame that the game will reside in.
public final class BB_Window {
    private JFrame window;
    private Canvas canvas;
    private Dimension windowDimension;
    
    // constructs the canvas, window, and buffer.
    public BB_Window(String title, int width, int height) {
        // creates dimension.
        windowDimension = new Dimension(width, height);
        
        // creates a canvas with a bunch of defaults.
        canvas = new Canvas();
        
        // sets a non-changeable size.
        canvas.setPreferredSize(windowDimension);
        canvas.setMinimumSize(windowDimension);
        canvas.setMaximumSize(windowDimension);
        
        // cannot be focused for event listeners.
        canvas.setFocusable(false);
        
        // creates window with a bunch of defaults.
        window = new JFrame();
        window.getContentPane().add(canvas);
        window.setTitle(title);
        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        window.setResizable(false);
        window.pack();
        window.setVisible(true);
        
        // center of screen.
        window.setLocationRelativeTo(null);
        
        BufferStrategy bufferStrategy = canvas.getBufferStrategy();
        
        if(bufferStrategy == null)
            canvas.createBufferStrategy(3);
    }
    
    // returns the frame.
    public JFrame getJFrame() {
        return window;
    }
    
    // returns the window width.
    public int getWidth() {
        return windowDimension.width;
    }
    
    // returns the window height.
    public int getHeight() {
        return windowDimension.height;
    }
    
    // returns the canvas.
    public Canvas getCanvas() {
        return canvas;
    }
}

Room.java

package game.room;

import java.awt.Graphics2D;

// future functionality might be added,
// which is why this class is abstract and not interface.

// represents a room/location in your Game
// eg, a town, a house, a forest, and a cave are all examples of rooms.
public abstract class Room {
    public abstract void init();
    public abstract void update();
    public abstract void render(Graphics2D graphics);
}

I feel that these files are the only ones needed to understand how my game library functions.

However, I notice that whenever I test out my game library, there is a very noticeable stutter that occurs every few seconds, and lasts for a few seconds. This is very annoying. However, what is more annoying is that this blocky/laggy movement is more noticeable on my computer than on other computers. What is going on with my computer for this to be occurring? How do I fix this? Here is an example of how my game library works.

Game.setRoom(new Room() {
    private int x, y;
    
    @Override
    public void init() {
        x = 0;
        y = 0;
    }
    
    @Override
    public void update() {
        x++;
        y++;
    }
    
    @Override
    public void render(Graphics2D graphics) {
        graphics.fillRect(x, y, 100, 100);
    }});

Game.init(new BB_Window("Test", 640, 640));

This example program draws a rectangle that moves diagonally down the screen. However, sometimes, the rectangle seems to "skip" pixels and moves more than it should. I tried recording my screen to show exactly what is going on, but for some reason the stutter is not showing up in the video.

I tried enabling hardware acceleration by doing

System.setProperty("sun.java2d.opengl", "true");

but that didn't do anything.

My computer isn't bad at all, so why is the game running more smoother on other computers than on mine?

And what can I do to fix this in my game library?

Thank you in advance.