repaint() klappt anders als vorgestellt

[Dickmann123]

Hi,

ich habe ein kleines Problem mit folgender Methode. Das Ergebnis, was ich haben will, stimmt zwar, jedoch möchte ich, dass bei jedem Schritt das JLabel "random_label" neu zu sehen ist. Sprich es soll von oben nach unten wandern, und ich möchte es sehen. Dazu habe ich an entsprechnender Stelle das repaint() eingefügt.

Die Methode wird aufgerufen durch Klick auf einen Button. Ergebnis ist wie gesagt das gewünschte, nur ich sehe eben nicht den "zeitlichen Verlauf", also das repaint() in der Schleife.

Ich würde mich über eine Antwort sehr freuen

public void roll(){
		wait = 50;
		compare = 0;
		random_position = 37;
		random_label.setLocation(5, random_position);
		random_label.setVisible(true);
		left_panel.repaint();
		random = (int)(Math.random()*(counter*10-counter*5)+counter*5);
		for (int i = 0; i < random; i++){
			random_position = random_position + 30;
			if (compare == counter){
				random_position = 37;
				compare = 0;
			}
			random_label.setLocation(5, random_position);
			left_panel.repaint();
			compare++;
			wait(wait);
		}
	}

 

[xehpuk]

Du blockierst wahrscheinlich den EDT.

Lesson: Concurrency in Swing (The Java™ Tutorials > Creating a GUI With JFC/Swing)

 

[Dickmann123]

Oha, danke für die Antwort

Was kann ich denn gegen eine solche Blockade machen? Aus deiner Verlinkung werde ich jetzt nicht ganz so schlau. Bin leider auch nicht so der Java-Pro.

 

[xehpuk]

Swing/AWT ist auch kein Anfängerthema. Wenn man es richtig machen will, muss man ein wenig Zeit reinstecken.
Ich kann dir eine Kurzfassung von dem geben, was dich im Tutorial erwartet:

Für das Zeichnen der Oberfläche ist der EDT (Event Dispatch Thread) zuständig. Führt dieser gerade anderweitigen Code aus, kann er die Oberfläche nicht mehr zeichnen, weil er eben beschäftigt ist. Deine Methode

roll()

wird wohl im EDT ausgeführt.* Erst wenn dieser mit der Methode fertig ist, kann er die Oberfläche wieder zeichnen, also aktualisieren. Daher siehst du bis zum Ende der Methode keine Änderungen, die Oberfläche wirkt eingefroren.

*Der Code in AWT-Listenern wird im EDT ausgeführt. Ich nehme an, dass deine Methode durch einen Klick auf einen Button ausgeführt wird, also von einem [JAPI]ActionListener[/JAPI] aufgerufen wird.
Ob ein Code gerade im EDT ausgeführt wird, kannst du auch über [JAPI]SwingUtilities#isEventDispatchThread()[/JAPI] herausfinden.

Um diese Blockierung des EDT zu verhindern, lagert man lang andauernde Methoden in andere Threads aus. Eine Erleichterung dieser Aufgabe erhält man durch den [JAPI]SwingWorker[/JAPI]. Dieser stellt passende Methoden bereit.

Wenn man Code, welcher die Oberfläche verändert, in einen Thread auslagert, muss man darauf achten, dass diese Änderungen wiederum im EDT ausgeführt werden, da es sonst zu den üblichen Problemen der Nebenläufigkeit (bspw. Race Condition) kommen kann. Um dies zu bewerkstelligen, gibt es dieses Konstrukt:

SwingUtilities.invokeLater(new Runnable() {
    @Override
    public void run() {
        // hier die Oberfläche verändern
    }
});

Dieses ruft man in dem Code auf, der in einem anderen Thread läuft. Ein Beispiel aus deinem Code, der in dieser

run()

ausgeführt werden müsste, wäre

random_label.setLocation(5, random_position);

.

Das wird jetzt bestimmt nicht alle Fragen geklärt haben oder eher noch mehr erzeugt haben. Daher würde ich dir wirklich raten, dich intensiv mit Nebenläufigkeit in Java und speziell Nebenläufigkeit in Swing (bereits oben verlinkt) auseinanderzusetzen.

 

[Dickmann123]

Okay, vielen Dank für die Antworten!!

Ich werde mich damit mal ein wenig beschäftigen.

Bis hierhin auf auf jeden Fall schonmal danke

 

[Dickmann123]

Muss ich, um dein Konstrukt umzusetzen, eine neue Klasse anlegen und dafür einen neuen Thread anlegen? Oder reicht es eine Methode dafür bereitzustellen, weil wenn ich es direkt in meine Methode einfüge funktioniert es nicht.

 

[SlaterB]

"Um diese Blockierung des EDT zu verhindern, lagert man lang andauernde Methoden in andere Threads aus."

du brauchst irgendein Thread-Objekt zunächst, das kann man auch anonym erzeugen bzw. ein anonymes Runnable übergeben,
hast du schonmal einen Thread laufen lassen?

SwingUtilities.invokeLater() wird erst später noch interessant

> weil wenn ich es direkt in meine Methode einfüge funktioniert es nicht.

hier kann man raten, was du wo wie gemacht hast und kommt wahrscheinlich doch nicht auf deine Variante,
besser immer Code posten,
in jedem Post alle 5 Min. vielleicht zuviel, jetzt nach mindestens einem Tag Pause und Vorschlag einer bedeutenden Änderung nicht falsch

 

[Dickmann123]

Okay, dann mach ich das mal:

Versuch eben war

public void roll(){
		wait = 50;
		compare = 0;
		random_position = 37;
		random_label.setLocation(5, random_position);
		random_label.setVisible(true);
		left_panel.repaint();
		random = (int)(Math.random()*(counter*10-counter*5)+counter*5);
		for (int i = 0; i < random; i++){
			random_position = random_position + 30;
			if (compare == counter){
				random_position = 37;
				compare = 0;
			}
			SwingUtilities.invokeLater(new Runnable() {
			    @Override
			    public void run() {
			    	System.out.println(javax.swing.SwingUtilities.isEventDispatchThread());
					random_label.setLocation(5, random_position);
			    }
			});
		
			left_panel.repaint();
			compare++;
			wait(wait);
			//gui.wait = gui.wait + 10;
		}
	}
[/Java]

Mein ActionListener ist übrigens in einer Extra-Klassen:

[code=Java]
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Roll_action implements ActionListener{

	GUI gui;
	
	public Roll_action(GUI Gui){
		gui = Gui;
	}
	
	public void actionPerformed(ActionEvent e) {
		gui.roll();
	}
}

Könnte ich nicht in diese Klasse (mit dem ActionListener) eine Background Task einfügen, wie hier beschrieben: Simple Background Tasks (The Java™ Tutorials > Creating a GUI With JFC/Swing > Concurrency in Swing)

 

[SlaterB]

SwingWorker geht genauso wie Thread, ja,
man muss es nur machen, bisher ist beides nicht vorhanden,
die actionPerformed()-Methode macht bisher die Arbeit, ruft die Methode roll() auf, ist erst fertig, wenn roll() abgearbeitet ist

Ziel muss es sein, eine nebenläufige Ausführung allein mit dem start-Kommando zu initialisieren und dann sofort
den ActionListener zu beenden, roll() wird erst später/ parallel ausgeführt

in dem Link steht gar nicht wie der SwingWorker gestartet wird,
hier ein Beispiel
Albert Attard: Practical Example of Swing Worker
execute() ziemlich weit unten,
wobei dort nicht aus einem Listener gestartet, sondern die ganze Zeit läuft, nicht ganz passend

für den Anfang mag es einfacher sein, erstmal Threads kennenzulernen,
aber wenn du zu SwingWorker schon was weißt/ noch beim Lesen bist, dann auch gut

 

[Dickmann123]

Also meinst du soll ich meinen Actionlistener in einem extra Thread ausführen, ohne den BackgroundWorker bzw. invoke?

 

[SlaterB]

du kannst den ActionListener nicht beeinflussen, der wird bei einem Button registriert und das war und ist genau alles an Einstellmöglichkeiten,
der AWT-Thread führt den ActionListener aus, soweit die festen Fakten,

die einzige Entscheidung ist, nochmal wiederholt, ob der ActionListener alles selber macht und solange die GUI blockiert wird,
oder ob jemand anders das nebenläufig macht, frisch gestartet vom ActionListener, vielleicht auch schon lange laufend und nur informiert

 

[Dickmann123]

Danke Leute es geht!

Habs jetzt über nen Thread gelöst:

public class roll_thread extends Thread {
	
	GUI gui;
	
	public roll_thread(GUI Gui){
		gui = Gui;
	}
	
	public void run() {
		gui.wait = 50;
		gui.compare = 1;
		gui.random_position = 37;
		gui.random_label.setLocation(5, gui.random_position);
		gui.random_label.setVisible(true);
		gui.left_panel.repaint();
		wait(gui.wait);
		gui.random = (int)(Math.random()*(gui.counter*10-gui.counter*5)+gui.counter*5);
		for (int i = 0; i < gui.random; i++){
			gui.random_position = gui.random_position + 30;
			if (gui.compare == gui.counter){
				gui.random_position = 37;
				gui.compare = 0;
			}
			gui.random_label.setLocation(5, gui.random_position);
			gui.left_panel.repaint();
			gui.compare++;
			gui.wait = gui.wait + (int)15/gui.counter;
			wait(gui.wait);
		    }
		for (int i = 0; i < 4; i ++){
			wait(300);
			gui.random_label.setVisible(false);
			wait(300);
			gui.random_label.setVisible(true);
		}
	}
	
	private void wait(int time){
		try{
		     Thread.sleep(time);
		}catch(InterruptedException e){}
	}
}

Vielen Dank nochmal

 

[Dickmann123]

Eine Frage hab ich aber noch:

Moment passiert jedes Mal wenn ich den Button drücke folgendes:

		roll_thread rthread = new roll_thread(gui);
		rthread.start();

Dabei wird ja jedes Mal ein neues Objekt vom Typ thread angelegt. Was passiert nachdem rthread.start(); fertig abgearbeitet ist? Terminiert dann der Thread oder bleibt er und ich habe mit mehrfachem drücken des Buttons einen immer voller werdenden Speicher? Sprich muss ich noch etwas einfügen, um den Thread nach Abarbeitung zu löschen?

 

[SlaterB]

der Thread terminiert, wenn die run-Methode beendet wird,

ein Thread ist eine teure Sache, würde mich nicht wundern wenn intern tausende Objekte angelegt werden,
aber das muss dich nicht jucken, schon gar nicht in GUIs, jede Bewegung mit der Maus gibt dem Programm Leerlauf für Mio. an Objekte
(Erzeugen, Verarbeiten, Aufräumen als Arbeitsaufwand, Platz zum Speichern ist natürlich immer eine andere Frage),
so erzeugt man ihn richtig und der Speicher wird durchaus wieder freigegeben

durchaus denkbar dass mehrere gleichzeitig laufen, ohne Terminierung werden es immer mehr usw.,
aber selbst dann musst du schon viel klicken,
vielleicht geht deine Maus kaputt bevor der Speicher voll ist um wie immer blumenreich paar Dimensionen zu übertreiben

natürlich sollte man immer beobachten und drauf achten, dass nichts schief läuft

 

[André Uhres]

Wir sollten die Animation allerdings noch "thread-safe" machen, sonst gibt die Anzeige möglicherweise irgendwann den Geist auf.

Swing-Event-Handler Code läuft auf einem speziellen Thread, der als Event Dispatch Thread bekannt ist. Der meiste Code, der Swing-Methoden aufruft, läuft auch auf diesem Thread. Dies ist notwendig, denn die meisten Swing-Komponenten-Methoden sind nicht "thread-safe" sind: Aufrufe von mehreren Threads bewirken Risiken von Thread Störungen oder Speicher Konsistenzfehler. Einige Swing-Komponenten-Methoden sind als "thread-safe" in der API-Spezifikation bezeichnet, diese können sicher von jedem Thread aufgerufen werden. Alle anderen Swing-Komponenten Methoden müssen vom Event Dispatch Thread aufgerufen werden. Programme, die diese Regel ignorieren können zwar die meiste Zeit funktionieren, sind aber abhängig von unvorhersehbaren Fehlern, die schwer zu reproduzieren sind.

Es ist nützlich, den Code, der auf dem Event Dispatch Thread läuft, als eine Reihe von kurzen Aufgaben zu sehen. Die meisten Aufgaben sind Aufrufe von Event-Handling Methoden, wie ActionListener.actionPerformed. Andere Aufgaben können durch die Anwendung mit invokeLater (oder invokeAndWait) geplant werden:

import javax.swing.SwingUtilities;

public class RollThread extends Thread
{

   private Gui gui;

   public RollThread(final Gui Gui)
   {
      gui = Gui;
   }

   @Override
   public void run()
   {
      gui.setWait(50);
      gui.setCompare(1);
      gui.setRandomPosition(37);
      SwingUtilities.invokeLater(new Runnable()
      {

         @Override
         public void run()
         {
            gui.getRandomLabel().setLocation(5, gui.getRandomPosition());
            gui.getRandomLabel().setVisible(true);
         }
      });
      wait(gui.getWait());
      gui.setRandom((int) (Math.random() * (gui.getCounter() * 10 - gui.getCounter() * 5) + gui.getCounter() * 5));
      for (int i = 0; i < gui.getRandom(); i++)
      {
         gui.setRandomPosition(gui.getRandomPosition() + 30);
         if (gui.getCompare() == gui.getCounter())
         {
            gui.setRandomPosition(37);
            gui.setCompare(0);
         }
         SwingUtilities.invokeLater(new Runnable()
         {

            @Override
            public void run()
            {
               gui.getRandomLabel().setLocation(5, gui.getRandomPosition());
            }
         });
         gui.setCompare(gui.getCompare() + 1);
         gui.setWait(gui.getWait() + 15 / gui.getCounter());
         wait(gui.getWait());
      }
      for (int i = 0; i < 4; i++)
      {
         wait(300);
         SwingUtilities.invokeLater(new Runnable()
         {

            @Override
            public void run()
            {
               gui.getRandomLabel().setVisible(false);
            }
         });
         wait(300);
         SwingUtilities.invokeLater(new Runnable()
         {

            @Override
            public void run()
            {
               gui.getRandomLabel().setVisible(true);
            }
         });
      }
   }

   private void wait(final int time)
   {
      try
      {
         Thread.sleep(time);
      } catch (InterruptedException e)
      {
      }
   }
}

Gruß,
André

 

[Dickmann123]

Okay gut

Vielen vielen Dank für eure Hilfe. Das mit dem Thread-safe hab ich jetzt auch übernommen.
Ihr wart eine super Hilfe, nochmal Dankeschön