# Button löst Schleife aus, danach friert die GUI ein ?



## Robbson (6. Dez 2003)

Hallo!
Habe mein derzeitiges GUI-Problem 'mal in einem kleinen einfachen Sourcecode verewigt.

Ich möchte über einen Button eine Schleife auslösen und die Schleife über denselben Button wieder stoppen.
Leider ist das Stoppen oder jede andere Event-Operation nicht mehr möglich, sobald ich die Schleife betreten habe,
da anscheinend die Behandlungsroutinen des Frame nicht mehr behandelt bzw. blockiert werden.

Gibt es eine Anweisung, um innerhalb der Schleife die Applikation daran zu erinnern, auch mal nach neuen Events, wie einem Button-Klick zu fragen?

Wenn nicht, dann kann man das ja nur noch über MultiThreads lösen, allerdings bräuchte ich diese Funktionalität mehrfach und will nicht für jede Schleife einen eigenen Thread erzeugen.

Interessant dabei ist: Sollte die Schleife direkt am Ende des Konstruktors aufgerufen werden, ist der Button zum Stoppen noch voll funktionstüchtig. Aus diesem Grund zweifel ich an der MultiThread-Lösung als einzigste Alternative.
Jedenfalls kann ich mich nicht erinnern, daß ich ein derartiges Problem mal mit der MFC/C++ hatte, die ich sonst (aber zur Zeit garnicht) nutze.

Wie läßt sich das Problem vermeiden?

Danke im Voraus,
Robbson




```
//QUELLCODE:

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

public class GuiTest extends Frame 
{
 boolean go;
 Button button_pause;
 
 public static void main(String[] args) 
 {
  GuiTest myGUI=new GuiTest();
 }
 
 public GuiTest() 
 {
  // Frame an Bildschirmgröße anpassen
  Dimension screensize=new Dimension();
  screensize=Toolkit.getDefaultToolkit().getScreenSize();
  setBounds(screensize.width/2-250, screensize.height/2-300, 400, 500);
  setResizable(false);
  setBackground(Color.darkGray);
  setLayout(null); 
  
  button_pause=new Button("Los");
  button_pause.setBounds(30,400,80,22);
  this.add(button_pause);
  button_pause.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e)
  {
   if(go==true)
   { 
    go=false; 
    button_pause.setLabel("Weiter"); 
   }
   else
   {
    go=true; 
    button_pause.setLabel("Pause"); 
    Tuwas(); 
   }
  }}); 
  
  // Fenster schließen abfangen
  addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent event)
  {
   setVisible(false);
   dispose();
   System.exit(0);  
  }});
  
  setVisible(true);
  
  // Schleife optional von hier aus das erste Mal starten
  go=false;
  //Tuwas();
 }
 
 
void Tuwas()
{
 int counter=0;
 while(go==true)
 {
  System.out.println("Hallo! "+counter);
  try
  {
   Thread.sleep(100); 
  }catch (InterruptedException e){}
  counter++;
 }
}

} // end class
```


----------



## AlArenal (6. Dez 2003)

Das ist ein Standardproblem bei grafischen Anwendungen. Swing läuft im Event Dispatcher Thread ab. Wenn du in die Event-Listener aufwändigen Code reinsetzt, hängt das GUI, weil es erst wieder Rechenzeit bekommt, wenn der Krims ausgeführt wurde, weil er halt in demselben Thread läuft.

Die Lösung ist also GUI-Code und Nicht-GUI-Code voneinander zu trennen und den Nicht-GUI-Code in einem eigenen Thread laufen zu lassen.

Das Ganze gibts fertig und ist hier nachzulesen und downzuloaden:
http://java.sun.com/docs/books/tutorial/uiswing/misc/threads.html

Desweiteren gibts dazu noch einen Artikel mit einer Demo, in der noch eine erweiterte Lösung drin ist:
http://www.javaworld.com/javaworld/jw-06-2003/jw-0606-swingworker.html


----------



## Robbson (6. Dez 2003)

Danke für die schnelle Antwort.

Wie es aussieht, komme ich also um die MultiThreads nicht d'rum herum.
Ich kannte mal nen Basic, da konnte man in die Programmschleife einen simplen Befehl einbauen,
der kurz auf eventuelle Events reagiert, wie so eine Art Wait für die GUI.
Aber sowas gibt's ja leider nicht in Java.  :cry: 

Mit der Thread-Programmierung habe ich derzeit keine Probleme, allerdings ist geplant, das Programm
in eine nicht MultiThread-fähige Sprache umzusetzen, sodaß man sich dann dort
was anderes einfallen lassen muß.
Im Übrigen habe ich derzeit einen zweiten Thread laufen, den ich als Zeitgeber nutze.

Schönen Abend noch,
Robbson.


----------



## Robbson (6. Dez 2003)

Hallo nochmal!

Ich habe mir mein Problem nocheinmal durch den Kopf gehen lassen und ein paar Tests gemacht.
Das Ergebnis: Das Einfrieren der Nutzeroberfläche hängt möglichweise nicht mit dem 
geschilderten Standartproblem des Event Dispatcher Thread zusammen.

Denn: Füge ich in den Konstruktor der Klasse den Loop ein oder rufe ich von dort pemanent die Tuwas() Funktion auf, funktioniert der Button einwandfrei... und zwar immerwieder OHNE Einfrieren.

Das Problem kommt zustande, wenn ich die Tuwas() Funktion direkt aus der 
Behandlungsroutine für den Button aufrufe.
Anscheinend läuft der Konstruktor der Klasse intern in einem anderen Thread als die GUI-Behandlungsroutinen
in derselben Klasse. Aber eine Klasse mit zwei Threads, obwohl man nur einen programmiert hat?

Grüße,
Robbson.


----------



## AlArenal (7. Dez 2003)

Der Event Dispatcher Thread heißt Event Dispatcher Thread, weil das der Thread ist, der sich um die Ausführung von (GUI-)Events kümmert. Der Konstruktor ist kein Eventhandler, ein ActionListener schon, denn Klicks auf Buttons, in Menüs, Aufpoppen eines Tooltips, resizen von Fenstern, Scrollen, etc.. sind alles Events


----------



## marsias (8. Dez 2003)

hi!

Guck dir mal die Klasse SwingUtilities an. vieleicht hilft sie dir auch weiter.

mfg


----------



## Guest (8. Dez 2003)

@marsias:

Leider kann ich in den SwingUtilities nichts passendes finden.
Wenn aber der EventHandler von Java blockiert sein soll, wieso funktioniert's dann mit dieser Modifikation: (?)



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

public class GuiTest extends Frame 
{
 boolean go;
 Button button_pause;
 
 public static void main(String[] args) 
 {
  GuiTest myGUI=new GuiTest();
 }
 
 public GuiTest() 
 {
  // Frame an Bildschirmgröße anpassen
  Dimension screensize=new Dimension();
  screensize=Toolkit.getDefaultToolkit().getScreenSize();
  setBounds(screensize.width/2-250, screensize.height/2-300, 400, 500);
  setResizable(false);
  setBackground(Color.darkGray);
  setLayout(null); 
  
  button_pause=new Button("Los");
  button_pause.setBounds(30,400,80,22);
  this.add(button_pause);
  button_pause.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e)
  {
   if(go==true)
   { 
    go=false; 
    button_pause.setLabel("Weiter"); 
   }
   else
   {
    go=true; 
    button_pause.setLabel("Pause"); 
    //Tuwas(); 
   }
  }}); 
  
  // Fenster schließen abfangen
  addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent event)
  {
   setVisible(false);
   dispose();
   System.exit(0);  
  }});
  
  setVisible(true);
  
  // "Programm"-Schleife hier laufen lassen
  go=false;
  while(true)
  {
   Tuwas();
  }
 }
 
 
void Tuwas()
{
 int counter=0;
 while(go==true)
 {
  System.out.println("Hallo! "+counter);
  try
  {
   Thread.sleep(100); 
  }catch (InterruptedException e){}
  counter++;
 }
}

} // end class
```

Grüße,
Robbson.


----------



## Ebenius (8. Dez 2003)

Also Dein EventHandlerThread ruft Deinen ActionListener auf, wenn Du einen Button klickst. Er arbeitet auch erst dann weiter, wenn Deine ActionListener-Methode (actionPerformed) zurückkehrt.

Natürlich kannst Du ohne Probleme einfach einen Text setzen, eine Farbe ändern, etc. Diese Dinge dauern nur sehr kurze Zeit und der Nutzer bekommt es nicht mit, dass der EventHandler kurz blockiert ist.

Wenn Du allerdings längere Aktionen ausführst, dann solltest Du sie aus der Laufzeit des EventHandlers herausbewegen (ergo in einen anderen Thread). Das heißt, dass eine (zugegeben nicht sehr schöne) Variante Deines Codes so ähnlich aussehen könnte:

```
button_pause.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent e) { 
		if(go==true) { 
			go=false; 
			button_pause.setLabel("Weiter"); 
		} 
		else { 
			go=true; 
			button_pause.setLabel("Pause"); 
			
			
			/* LOOK HERE!!! */
			new Thread(new Runnable() {
				public void run() {
					Tuwas(); 
				}
			}, "Tuwas UI Thread").start();
		} 
	}
});
```

Der Unterschied zwischen Deinem Code mit der auskommentierten _Tuwas()_-Methode und dem anderen ist, dass _Tuwas()_ lange braucht und deshalb das ganze GUI lange wartet. Das andere Zeug geht sehr schnell und damit bekommts auch keiner mit...

Falls die Erklärung nicht ausreicht und Du englisch kannst, sollte das Swing Tutorial - Event Handling helfen.

Viel Spaß,
Ebenius


----------

