kommunikation zwischen dialog und threads

[pymote]

hallo zusammen,
ich habe ein grundlegende frage zur kommunikation zwischen dialogen und threads. z.b. habe ich ein programm mit einer spalte in der alle abläufe (threads, etc.) protokolliert werden soll. mehrere threads können vom benutzer gestarten und ggf. beendet werden.
bisher habe ich dazu am ende der thread-klasse die meldung (z.b. "thread1 wurde gestartet") dem protokoll-dialog übergeben.

display.asyncExec(new Runnable(){ 
			public void run() {
				dialog.listProtocol.add("thread1 gestartet");
		}});

dazu muss ich aber jedem thread das display (display) und das protokoll-gui-element (listProtocol) übergeben. rufe ich diesen thread z.b. über einen weiteren dialog auf (z.b. printThread über printDialog) muss ich auch beim erzeugen des printDialogs, das listProtocol des hauptdialogs übergeben, welches dann wiederum dem printThread übergeben wird.
was ich aber nicht haben will, ist eine solche verkettung von werteübergaben.
ist das ein falscher ansatz von mir?
gibt es eventuell design patterns die sich diesem problem annehmen?

vielen dank!

 

[Guest]

Es ist ein ganz normales Observer/Observable Szenario.
Lass das Dialogfenster den ganzen Display Part erledigen. Die Threads müssen
nichts von dem Dialog wissen und umgekehrt. Mit einem Singleton kannst Du
den Event-Austausch erledigen.

public class ThreadStateEvent extends TypedEvent
{
  Informationen über den Thread
}

public interface ThreadStateListener extends SWTEventListener
{
  public void threadStarted(ThreadStateEvent event);
  public void threadFinished(ThreadStateEvent event);
  // etc.
}

public class ThreadStateListenerSupport
{
  Als Singleton implementieren

  public void addThreadStateListener(ThreadStateListener listener)
  {
    ...
  }

  public void removeThreadStateListener(ThreadStateListener listener)
  {
    ...
  }

  public void fireThreadStarted(Object thread) // oder andere Parameter z.B. ThreadStateProvider siehe unten
  {
    ... hier ThreadStateEvent erzeugen und an alle Listener schicken (Dein Dialogfenster ist ein solcher Listener)
  }

  public void fireThreadFinished(Object thread) // oder andere Parameter z.B. ThreadStateProvider siehe unten
  {
    ... hier ThreadStateEvent erzeugen und an alle Listener schicken (Dein Dialogfenster ist ein solcher Listener)
  }
}


ThreadStateListenerSupport.getInstance().addThreadStateListener(deinDialog); // Im Konstruktor des Dialogs
ThreadStateListenerSupport.getInstance().removeThreadStateListener(deinDialog); // in dispose() des Dialogs

ThreadStateListenerSupport.getInstance().fireThreadStarted(this); // In deinen Threads
ThreadStateListenerSupport.getInstance().fireThreadFinished(this); // In deinen Threads

Deine Threads könnten noch ein Interface implementieren, das Methoden definiert,
über die der Listener sich die Informationen beschaffen kann.
z.B.

public interface ThreadStateProvider
{
  public String getThreadName();
  public int getThreadState();
  // etc.
}

 

[pymote]

ok, danke zunächst mal.
allerdings habe ich probleme (oder fehlendes verständnis) deine erklärung auf mein programm zu übertragen.
Was soll ich denn genau in dieser Methode implementieren?

public void addThreadStateListener(ThreadStateListener listener)
	{
	}

Und wie schicke ich ein ThreadStateEvent an meinen Dialog?
Bei diesem Versuch ....

public void fireThreadFinished(Object thread)
	{
		ThreadStateEvent tse = new ThreadStateEvent(thread);
		tse.notifyAll();
	}

bekomme ich folgenden Fehler:

java.lang.IllegalMonitorStateException: current thread not owner

ich hab mir mal ne andere erklärung für das observer pattern angesehen.

wenn ich es richtig verstanden habe,
- muss mein printThread die klasse observable erweitern.
- mein dialog mit der protokolliste implementiert die schnittstelle observer.
- dann weise ich meinem thread den observer (dialog) zu.
- beim ende des threads geb ich die nachricht mit der notify-methode an den dialog (z.b. printThread.addToList("Druckauftrag bearbeitet");

noch eine kleine anmerkung: mein printThread erbt ja bereits schon von 'Thread'? wie kann ich ihn dennoch als 'observable' implementieren

gruss pymote

 

[Guest]

Nein nichts mit Observer/Observable. Das habe ich nur als Beispiel genannt,
da es typisch für sowas ist.
Dein Dialog muss nur das Interface ThreadStateListener implementieren.
Deine Threads das Interface ThreadStateProvider.

public class ThreadStateListenerSupport
{
  private static ThreadStateListenerSupport instance=null;
  private List listenerList = new ArrayList();

  private ThreadStateListenerSupport()
  {
  }

  public static ThreadStateListenerSupport getInstance()
  {
    if(instance == null)
      instance = new ThreadStateListenerSupport();

    return instance;
  }

  public void addThreadStateListener(ThreadStateListener listener)
  {
    if(!listenerList.contains(listener))
      listenerList.add(listener);
  }

  public void removeThreadStateListener(ThreadStateListener listener)
  {
    listenerList.remove(listener);
  }

  public void fireThreadStarted(ThreadStateProvider thread)
  {
    ThreadStateEvent event = new ThreadStateEvent(thread);
    for(ThreadStateListener listener : listenerList)
      listener.threadStarted(event);
  }

  public void fireThreadFinished(ThreadStateProvider thread)
  {
    ThreadStateEvent event = new ThreadStateEvent(thread);
    for(ThreadStateListener listener : listenerList)
      listener.threadFinished(event);
  }
}

Rest, wie in meiner ersten Antwort beschrieben.

 

[pymote]

Dank dir, jetzt hats funktioniert. alles was ich noch beachten musste, war dass ich nicht vergesse das beschreiben der protokolliste in einer runnable-umgebung ablaufen zu lassen:

public void threadFinished(ThreadStateEvent event) {
		display.asyncExec(new Runnable(){
			public void run() {
				listProtocol.add("Thread1 beendet");				
			} 
		});		
	}

gruss pymote