Die Ausführung eines Programmes verzögern

Die grafische Darstellung von Sortiervorgängen kann nur dann sinnvoll verfolgt werden, wenn die Sortierung nach jedem Schritt angehalten wird. Bei den bereits vorgestellten Beispielen zu den Sortiervorgängen wurde (willkürlich) dazu eine lange Zählschleife mit leerem Inhalt verwendet. Dieses Verfahren hat allerdings mehrere Nachteile. So wird die CPU mit dem Abarbeiten einer ``sinnlosen'' Schleife belastet, und die Verzögerung kann auf moderneren, schnelleren Systemen wieder zu gering sein... Um beispielsweise in allen Umgebungen eine Verzögerung von einer Sekunde pro Sortierschritt zu gewährleisten, ist es wesentlich günstiger, einen Thread zum Sortieren zu verwenden, der pro Schritt 1000 Millisekunden angehalten wird.

Das folgende Beispiel zeigt das Sortieren von Elementen mit dem so genannten ``Bubble-Sort''-Verfahren. Um die einzelnen Tauschvorgänge beobachten zu können, wird jeder Tauschvorgang für 50 Millisekunden angehalten.

import java.awt.*;
import java.awt.event.*;
import java.util.Random;

public class ThBubble extends Frame implements Runnable{

    static Thread proz;
    static int i;
    static int j;
    int h[] = new int[101];

    public ThBubble() {
        Random r = new Random();
        for (int i=1; i<=100; i++) h[i] = (int) (r.nextDouble()*80);
        proz = new Thread(this, "BubbleSort");
        proz.start();
    }

    public void run() {
        int hilfsvar;
        while (true) {
            for (i=2;i<=100;i++) {
                for (j=100;j>=i; j--) {
                    if (h[j-1]>h[j]) {
                        hilfsvar=h[j];
                        h[j] = h[j-1];
                        h[j-1] = hilfsvar;
                        repaint();
                        try {
                            Thread.sleep(100);
                        }
                        catch (InterruptedException ie) {
                        }
                    }
                }
            }
        }
    }

    public void paint(Graphics g) {
        g.setColor(Color.white);
        g.fillRect((j-1)*5,20,5,100);
        g.fillRect(j*5,20,5,100);
        g.setColor(Color.black);
        g.fillRect((j-1)*5,120-h[j-1],3,h[j-1]);
        g.fillRect(j*5,120-h[j],3,h[j]);
        g.setColor(Color.white);
        g.fillRect(5,0,500,120);
        g.setColor(Color.black);
        
        for (int l=1;l<=100;l++) {
            g.fillRect(l*5,120-h[l],3,h[l]);
        }
    }

    public static void main (String [] args) {
        ThBubble sprog = new ThBubble();
        WindowListener wl = new WindowAdapter() {
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }
            };
        sprog.addWindowListener(wl);
        sprog.setTitle("Bubblesort");
        sprog.setLocation(100,100);
        sprog.setSize(520,120);
        sprog.show();
    }
}

Die paint()-Methode zeichnet ein weißes Rechteck über die alte Ausgabe und dann den aktuellen Werten im Array entsprechend große schwarze Rechteckstreifen. Die Ausgabe wird durch die repaint()-Methode ausgelöst, die in der run()-Methode gemeinsam mit einer Unterbrechnung des Threads um 100 Millisekunden auftritt. Beachte, dass die Methode Thread.sleep() in Zusammenhang mit einem try-catch-Block verwendet werden muss.