Wie funktioniert JComponent.paintImmediately () - arbeiten in Java-Swing?

Meinem Verständnis, wenn Sie anrufen paintImmediately, rufen Sie den folgenden code:

        Component c = this;
        Component parent;

        if(!isShowing()) {
            return;
        }

        JComponent paintingOigin = SwingUtilities.getPaintingOrigin(this);
        if (paintingOigin != null) {
            Rectangle rectangle = SwingUtilities.convertRectangle(
                    c, new Rectangle(x, y, w, h), paintingOigin);
            paintingOigin.paintImmediately(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
            return;
        }

        while(!c.isOpaque()) {
            parent = c.getParent();
            if(parent != null) {
                x += c.getX();
                y += c.getY();
                c = parent;
            } else {
                break;
            }

            if(!(c instanceof JComponent)) {
                break;
            }
    }
    if(c instanceof JComponent) {
        ((JComponent)c)._paintImmediately(x,y,w,h);
    } else {
        c.repaint(x,y,w,h);
    }

So, es sei denn, dies ist nicht eine JComponent Sie am Ende aufrufen _paintImmediately() die endet Aufruf paint(Graphics) schlägt die stack-trace-unter (gefangen von einem Stück code, das werde ich am Ende dieses post):

Thread [pool-1-thread-1] (Suspended)    
    TestPaint$1.paint(Graphics) line: 23    
    TestPaint$1(JComponent).paintToOffscreen(Graphics, int, int, int, int, int, int) line: 5221 
    RepaintManager$PaintManager.paintDoubleBuffered(JComponent, Image, Graphics, int, int, int, int) line: 1482 
    RepaintManager$PaintManager.paint(JComponent, JComponent, Graphics, int, int, int, int) line: 1413  
    RepaintManager.paint(JComponent, JComponent, Graphics, int, int, int, int) line: 1206   
    TestPaint$1(JComponent)._paintImmediately(int, int, int, int) line: 5169    
    TestPaint$1(JComponent).paintImmediately(int, int, int, int) line: 4980 
    TestPaint$1(JComponent).paintImmediately(Rectangle) line: 4992  
    TestPaint$3.run() line: 50  
    ThreadPoolExecutor.runWorker(ThreadPoolExecutor$Worker) line: 1110  
    ThreadPoolExecutor$Worker.run() line: 603   
    Thread.run() line: 722  

Aber wenn Sie versuchen, fordern auch repaint() gleichzeitig (aus einem anderen Thread), sehen Sie, dass beide zur gleichen Zeit laufen (ich habe versucht, treten in den code mit debuger und Malerei nie aufgehört auftreten in dem anderen Thread) es scheint, dass bei den Java-code-Ebene gibt es nicht viel Synchronisation (zumindest konnte ich nicht vor Ort nichts). Also, wenn Sie am Ende in einer änderung des Komponentenstatus in der EDT, ich glaube, die Ergebnisse sind ziemlich unvorhersehbar, und Sie sollten vermeiden, eine solche situation mit allen Mitteln.

Nur um zu veranschaulichen mein Punkt, ich habe versucht, ändern Sie den Zustand einer variable innerhalb der paint Methode, fügen Sie eine sleep erhöhen das Risiko von Kollisionen zwischen den 2 Threads (EDT und die anderen) und es obvisouly scheint, dass es keine Synchronisation zwischen den beiden Threads (die System.err.println() ausgegeben null von Zeit zu Zeit).

Nun möchte ich Fragen, warum Sie brauchen, um eine paintImmediately. Es sei denn, Sie blockieren die EDT, es gibt nicht so viele Gründe zu einer solchen Sache.

Unten ist der code, den ich verwendet, um zu testen, diese Dinge (ziemlich in der Nähe die man geschrieben in der Frage). Der code ist nur dazu da, um zu versuchen zu verstehen, was Los ist, nicht zu zeigen, wie Sie ausführen ordnungsgemäße Malerei noch keine gute Swing-Praxis.

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import java.util.concurrent.Executors;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;

public class TestPaint {

    protected void initUI() {
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setTitle(TestPaint.class.getSimpleName());
        final Random rand = new Random();
        final JPanel comp = new JPanel() {
            private String value;

            @Override
            public void paint(Graphics g) {
                value = "hello";
                super.paint(g);
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    //TODO Auto-generated catch block
                    e.printStackTrace();
                }
                g.setColor(new Color(rand.nextInt(256), rand.nextInt(256), rand.nextInt(256)));
                g.fillRect(0, 0, getWidth(), getHeight());
                if (SwingUtilities.isEventDispatchThread()) {
                    System.err.println("Painting in the EDT " + getValue());
                } else {
                    System.err.println("Not painting in EDT " + getValue());
                }
                value = null;
            }

            public String getValue() {
                return value;
            }
        };
        frame.add(comp);
        frame.setSize(400, 400);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        Timer t = new Timer(1, new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                comp.repaint();
            }
        });
        t.start();
        Executors.newSingleThreadExecutor().execute(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    comp.paintImmediately(comp.getBounds());
                }
            }
        });
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                new TestPaint().initUI();
            }
        });
    }

}