为什么我的自定义 JPanel 没有被绘制/重新绘制，即使我正在从事件队列中绘制并覆盖 paintComponent()？

Question

I trying to make my first Swing application and i cannont for the life of me figure out why nothing is painted and I only get an empty Window.

I am using SwingUtilities.invokeLater to start the AWT Event Queue Thread, in my Controller I am using a SwingWorker doInBackground() for my Main Loop, processing my Model code.

I use events to pass changes from my model to the controller who then puts it in a concurrent change queue which the View uses to update itself.

I have been at this for hours and still no idea why it won't paint. I'm painting from the Event Queue Thread, I'm overriding paintComponent and call super.paintComponent() like it's supposed to be done (to my knowledge).

The sys.outs indicate that the rest of the application logic seem to work fine.

I tried to cut down the code to the necessities but it's still a wall of text, sorry for that. It should compile though.

import javax.swing.SwingUtilities;

public class Application {
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                Controller controller = new Controller("Swing MVC Test Application");
                controller.start();
            }
        });
    }
}

Model

import javax.swing.event.EventListenerList;

public class Model {

    private EventListenerList listeners = new EventListenerList();
    private int[][] someChange = new int[][]{
            { 0,1},
            { 2,3},
            {4,5}
    };
    private int gameLoopCounter = 0;

    public Model(ModelChangeListener listener) {
        listeners.add(ModelChangeListener.class, listener);
    }

    protected synchronized void notifyListeners(ModelChangeEvent event) {
        for (ModelChangeListener l : listeners.getListeners(ModelChangeListener.class))
            l.receiveModelChange(event);
    }

    public void nextGameLoopIteration() {
        notifyListeners(new ModelChangeEvent(this, someChange[gameLoopCounter]));
        gameLoopCounter++;
    }

}

Controller

import javax.swing.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Controller implements ModelChangeListener {
    private static final int QUEUE_SIZE = 20;

    private Model model;
    private View view;

    public final BlockingQueue<ModelChangeEvent> changeQueue;

    public Controller(String title) {
        this.changeQueue = new ArrayBlockingQueue<ModelChangeEvent>(QUEUE_SIZE) ;
        this.model = new Model(this);
        this.view = new View(this, title);
    }
    public void start() {
        SwingWorker<Void, Void> mainLoop = new SwingWorker<Void, Void>() {
            @Override
            protected Void doInBackground() throws Exception {
                while (true) {
                    if (1 == 0) return null;

                    model.nextGameLoopIteration();
                }
            }
        };
        mainLoop.execute();

        long time = System.currentTimeMillis();
        while (true){
            time += View.MILLIS_PER_LOOP;
            try {
                view.processModelUpdates();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                Thread.sleep(Math.max(0, time - System.currentTimeMillis()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void receiveModelChange(ModelChangeEvent e) {
        try {
            this.changeQueue.put(e);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }
}

View

import javax.swing.*;
import java.awt.*;
import java.util.concurrent.TimeUnit;

public class View extends JPanel {
    public static final int MILLIS_PER_LOOP = 1000;
    private static final int CELLSIZE = 40;

    private Controller controller;
    private myPanel myPanel;

    private ModelChangeEvent currentModelState;

    public View(Controller controller, String title) throws HeadlessException {
        this.controller = controller;

        this.setSize(1500,1100);

        initFrame(title);
    }

    private void initFrame(String title) {
        JFrame frame = new JFrame(title);
        frame.setContentPane(this);
        frame.setSize(1600, 1200);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public void processModelUpdates() throws InterruptedException {
        this.currentModelState = this.controller.changeQueue.poll(1, TimeUnit.SECONDS);
        if (currentModelState != null) {
            // do some processing....
            this.repaint();
        }

    }
    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        // draw something
        g.drawOval(currentModelState.getMovementExample()[0],
                currentModelState.getMovementExample()[1],
                CELLSIZE, CELLSIZE);
    }
}  

Event Listener Interface and Class

import java.util.EventListener;

public interface ModelChangeListener extends EventListener {
          void  receiveModelChange( ModelChangeEvent e);
}

Event Listener Class

import java.util.EventObject;

public class ModelChangeEvent extends EventObject {
    private int[] movementExample;

    public int[] getMovementExample() {
        return movementExample;
    }

    public ModelChangeEvent(Object source, int[] change) {
        super(source);
        movementExample  = change;
    }

    @Override
    public Object getSource() {
        return super.getSource();
    }
}

Answer 1

I am using a SwingWorker doInBackground() for my Main Loop,

A couple of things stick out:

model.nextGameLoopIteration();

That is basically an infinite loop since you don't have a timing mechanism. For a game you would generally need a Thread.sleep(…) to allow the game to repaint itself and reset the game state.

Also, I actually see a second loop:

controller.start();

The above code is executed on the EDT.

In the start() method withing a while (true) loop you have:

Thread.sleep(Math.max(0, time - System.currentTimeMillis()));

So this is also an infinite loop which will cause the EDT to sleep, meaning it can't respond to events or repaint the GUI.

Not sure why you have two loops, but you definitely should not be sleeping on the EDT.