Java thread not calling paintComponent

Question

I have a problem. I have to make an app, which would contain n number of Threads which would move the balls around the circle (with different velocities). Now I've got my Thread extending JComponent and implementing Runnable . Everything works just fine, except the run() method doesn't seem to call paintComponent. How can I fix that? The code:

Thread (Kulka.java):

package internet;

import internet.RotateWheel.TestPane;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Point;
import static java.lang.Thread.sleep;
import javax.swing.JComponent;
import javax.swing.JPanel;

public class Kulka extends JComponent implements Runnable{
    int x, y;
    float predkosc;
    float obecna_predkosc = 0f;
    TestPane parent;

    public Kulka(TestPane parent, int x, int y, float v){
        this.predkosc = v;
        this.x = x;
        this.y = y;
        this.parent = parent;
    }

    public Point getPointOnCircle(float degress, float radius) {

        int x = Math.round(getWidth() / 2);
        int y = Math.round(getHeight() / 2);

        double rads = Math.toRadians(degress - 90);

        int xPosy = Math.round((float) (x + Math.cos(rads) * radius));
        int yPosy = Math.round((float) (y + Math.sin(rads) * radius));

        return new Point(xPosy, yPosy);

    }

    @Override
    public void paintComponent(Graphics g){
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D) g;
        g2.setColor(Color.RED);
        int diameter = Math.min(getWidth(), getHeight());
        int x = (getWidth() - diameter) / 2;
        int y = (getHeight() - diameter) / 2;

        g2.setColor(Color.RED);
        float innerDiameter = 20;
        System.out.println("Diameter: " + diameter);
        Point p = getPointOnCircle(obecna_predkosc, (diameter / 2f) - (innerDiameter / 2));
        g2.fillOval(x + p.x - (int) (innerDiameter / 2), y + p.y - (int) (innerDiameter / 2), (int) innerDiameter, (int) innerDiameter);        
    }

    public synchronized void run(){
        while (true){
            //System.out.println(obecna_predkosc);
            try {
                System.out.println(predkosc);
                this.repaint();
                sleep(1000);
            } catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

}

This is what happens:

Class with Frame and Panel:

package internet;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.LinkedList;
import java.util.Random;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class RotateWheel {

    public static void main(String[] args) {
        new RotateWheel();
    }

    public RotateWheel() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }



    public class TestPane extends JPanel {

        LinkedList<Thread> kulki =  new LinkedList<Thread>();        
        int n = 5;
        private float degrees = 0;
        Random random = new Random();

        public TestPane() {            
            /*Timer timer = new Timer(60, new ActionListener() {

                @Override
                public void actionPerformed(ActionEvent e) {
                    degrees += 1f;

                    repaint();
                }
            });
            timer.start();*/
        }


        public Point getPointOnCircle(float degress, float radius) {

            int x = Math.round(getWidth() / 2);
            int y = Math.round(getHeight() / 2);

            double rads = Math.toRadians(degress - 90);

            int xPosy = Math.round((float) (x + Math.cos(rads) * radius));
            int yPosy = Math.round((float) (y + Math.sin(rads) * radius));

            return new Point(xPosy, yPosy);

        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();

            int diameter = Math.min(getWidth(), getHeight());
            int x = (getWidth() - diameter) / 2;
            int y = (getHeight() - diameter) / 2;

            g2d.setColor(Color.GREEN);
            g2d.drawOval(x, y, diameter, diameter);

            g2d.setColor(Color.RED);
            float innerDiameter = 20;

            if (kulki.isEmpty()){
                for (int i=0; i<n; i++){
                    Point p = getPointOnCircle(degrees, (diameter / 2f) - (innerDiameter / 2));
                    Kulka kulka = new Kulka(this, p.x, p.y, random.nextFloat() * (5f - 2f) + 1f);
                    Thread watek = new Thread(kulka);
                    kulki.add(watek);                                       
                }
                for (Thread t: kulki){
                    t.start();
                }
            }

            System.out.println("No elo XD");


            g2d.dispose();
        }


    }

}

Answer 1

Let's look at the obvious issues

• In TestPane , you create a series of Kulka components, but never add them to anything
• You can the state of the UI from within the paintComponent method
• There's no (obvious) reason for Kulka to be any type of component

What are the possible solutions?

• Create your Kulka elements within the constructor of the class or some other method unrelated to the UI
• Painting should paint the current state, nothing else
• Kulka could be just a POJO, which has some means to paint to a Graphics context and update itself as required. Technically, this could be self contained, but there's nothing wrong with having it rely on an external update source

Kulka...

This is a pretty basic class, it's reliant on an external updater and painter, which makes it flexible. This means you could use multiple threads, a single thread or a Timer to act as the updater and it won't care. It also doesn't care about how it's painted, only that it requires a Graphics context to do it.

public class Kulka {

    private PaintContainer container;
    private float angle;
    private float delta;

    public Kulka(PaintContainer container, float angle, float delta) {
        this.container = container;
        this.angle = angle;
        this.delta = delta;
    }

    public void update() {
        angle += delta;
        container.wasUpdated(this);
    }

    public void paint(Graphics2D g2d) {
        int diameter = Math.min(container.getWidth(), container.getHeight());
        float innerDiameter = 20;

        Point point = getPointOnCircle(angle, (diameter / 2f) - (innerDiameter / 2));
        g2d.setColor(Color.RED);
        g2d.fill(new Ellipse2D.Double(point.x, point.y, innerDiameter, innerDiameter));
    }

    public Point getPointOnCircle(float degress, float radius) {

        int x = Math.round(container.getWidth() / 2);
        int y = Math.round(container.getHeight() / 2);

        double rads = Math.toRadians(degress - 90);

        int xPosy = Math.round((float) (x + Math.cos(rads) * radius));
        int yPosy = Math.round((float) (y + Math.sin(rads) * radius));

        return new Point(xPosy, yPosy);

    }

}

PaintContainer...

Because I'm a crusty old developer, I prefer to use interfaces where I can, but strictly speaking, it's not required. I've used it here to force the separation and prevent the Kulka class from interacting with the painting container in ways I don't want it to.

public interface PaintContainer {
    public int getWidth();
    public int getHeight();

    public void wasUpdated(Kulka kulka);
}

Updater...

Okay, so based on your requirements, you need a single thread for each Kulka , as I've noted, this is a bad idea and won't scale well, but this is what you require.

This simply acts as a wrapper around the Kulka and the Thread . Now, it would be possible for Kulka to be self contained and update itself, but I thought it'd be better if Kulka had no concept of how it was updated, only that it can.

public class Updater implements Runnable {
    private Kulka kulka;
    private Thread t;

    public Updater(Kulka kulka) {
        this.kulka = kulka;
    }

    public void start() {
        if (t == null) {
            t = new Thread(this);
            t.start();
        }
    }

    @Override
    public void run() {
        while (true) {
            kulka.update();
            try {
                Thread.sleep(16);
            } catch (InterruptedException ex) {
            }
        }
    }
}

The painter...

I did think about trying to use a "smart" painting process, only updating those elements which have changed, but the fact is, on each paint cycle, we need to repaint everything any way :P

public class TestPane extends JPanel implements PaintContainer {

    private Set<Kulka> entities;

    public TestPane() {
        entities = new HashSet<>(10);
        for (int index = 0; index < 10; index++) {
            float degrees = (float)(Math.random() * 359d);
            float delta = (float)((Math.random() * 10d) - 5d);
            Kulka kulka = new Kulka(this, degrees, delta);
            entities.add(kulka);
            Updater updater = new Updater(kulka);
            updater.start();
        }
    }

    @Override
    public Dimension getPreferredSize() {
        return new Dimension(200, 200);
    }

    @Override
    synchronized protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g.create();

        int diameter = Math.min(getWidth(), getHeight());
        int x = (getWidth() - diameter) / 2;
        int y = (getHeight() - diameter) / 2;

        g2d.setColor(Color.GREEN);
        g2d.drawOval(x, y, diameter, diameter);

        g2d.setColor(Color.RED);
        g2d.dispose();

        for (Kulka kulka : entities) {
            g2d = (Graphics2D) g.create();
            kulka.paint(g2d);
            g2d.dispose();
        }
    }

    @Override
    synchronized public void wasUpdated(Kulka kulka) {
        repaint();
    }

}