Wie Sie sagen, wenn Grafiken.drawImage() tatsächlich abgeschlossen hat

Dies ist meine erste Frage hier und ich hoffe ich bekomme eine Antwort oder eine Idee, die mir helfen wird.

Ich bin Zeichnung ein großes Bild und skalieren Sie es nach unten mit der Methode drawImage(). Ich habe dann sofort zeichnen ein anderes Bild mit drawImage (), dass ich erwarte, dass gezeichnet werden, der auf der Oberseite des vorherigen (zweiten). Das problem ist, dass drawImage sofort zurückkehrt, auch wenn es dauert ~50 ms zu skalieren und zu Rendern, das erste Bild. Die meisten der Zeit, das zweite Bild landet unter den ersten, weil es gemalt ersten während große ersten verarbeitet werden. Im Grunde ist es sowieso zu zwingen drawImage() blockiert, bis es fertig ist, oder irgendwie schauen, Wann es abgeschlossen ist?

Ich bin mir bewusst, der ImageObserver parameter, welche gut funktioniert, wenn das herunterladen eines Bildes aus dem Internet oder so etwas, aber wenn eine bereits geladene BufferedImage, es wird nie ausgelöst ImageUpdate() nur nach dem skalieren und zeichnen. Im Grunde seit das erste Bild ist schon "geladen" nie Kontakte der ImageObserver, es dauert nur wie ~50 ms in einem eigenen thread zu verarbeiten, niemals die Benachrichtigung, wenn es abgeschlossen ist.

Weiß jemand, wie man entweder die Kraft, es zu blockieren oder zu warten, bis es komplett fertig, die Skalierung und das blitting eines Bildes? Und natürlich mit Gewinde.sleep(xx) ist ein kompletter hack und nicht lebensfähig aufgrund der Unterschiede zwischen computer-Geschwindigkeiten. Alle diese übergabe passiert ist, ist auf der Event-thread innerhalb der paint(Graphics g) - Methode.

Dank!

EDIT: Das folgende ist der code, den ich derzeit habe, um Ihnen eine Vorstellung von dem Problem:

public void paint(Graphics window)
{
    window.setColor(Color.WHITE);
    window.fillRect(0, 0, Settings.width * Settings.aaFactor, Settings.height * Settings.aaFactor);

    Graphics2D window2D = (Graphics2D) window;
    window2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
    window2D.drawImage(this.image, 0, 0, Settings.width, Settings.height, null);

    try
    {
        Thread.sleep(50);
    }
    catch (InterruptedException e)
    {
        e.printStackTrace();
    }

    window2D.drawImage(this.image2, 0, 0, null);

    repaint();
}

EDIT 2: Um besser zu erklären, das problem, das ich spreche, ich habe einige Beispiel-code, der tut besser, was ich versuche zu erklären. Starten Sie es und Sie werden sehen, dass es flackert, wo manchmal das erste Bild ist unten (wie es sein soll), aber die meisten der Zeit, wird es eine Obere (zweite), was aber falsch ist. Ändern Sie einfach die Datei-Pfade auf ein kleines Bild und ein großes Bild.

public class Main extends Applet implements ImageObserver
{
    private BufferedImage imageA;
    private BufferedImage imageB;

    @Override
    public void init()
    {
        try
        {
            this.imageA = ImageIO.read(new File("C:\\LargeImage.jpg"));
            this.imageB = ImageIO.read(new File("C:\\SmallImage.jpg"));
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }

    @Override
    public void update(Graphics g)
    {
        paint(g);
    }

    @Override
    public void paint(Graphics g)
    {
        Graphics2D w = (Graphics2D) g;
        w.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
        w.drawImage(this.imageA, 0, 0, 50, 50, this);//This takes a while to do (scaling down and drawing)...
        w.drawImage(this.imageB, 10, 10, null);//While this is drawn quickly, before A is done.

        repaint();
    }

    @Override
    public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height)
    {
        System.out.println("ImageObserver fired, done drawing image.  NEVER CALLED!");
        return false;
    }
}