Prozedur gegen sich selbst absichern

[DelphiManiac]

Wenn ich das so mache habe ich aber leider ein Problem:


Ich habe ja gesagt, dass ich z.B.: die Methode im Button aufrufe,

Delphi-Quellcode:

procedure TMainGUI.btnSaveDichteDampClick(Sender: TObject);
begin
  Screen.Cursor:=crHourGlass;
  if not(TuWas() = 0)) then
  begin
//  Fehler ausgeben
  end;
  Screen.Cursor:=crDefault;
end;

Jetzt wird ja im Prinzip durch das zurücksetzen des Cursors signalisiert, dass die Methode fertig ausgeführt wurde, wenn ich das jetzt im Thread mache, habe ich diese direkte Rückkopplung nicht...

Dann müsste ich wieder auf den Thread warten...
//edit : Delphicode geändert

[jfheins]

Du kannst mit MsgWaitForMultipleObjects auf Messages und den Thread warten ;)

Wenn messages eintreten, kannst du diese abarbeiten lassen, und wieder warten, wenn der Thread fertig ist, den Cursor wieder ändern ...

Ungefähr sowas: http://www.delphipraxis.net/internal...=696510#696510 ;)

[DelphiManiac]

Also im Prinzip gibt mir die Methode immer einen Wert zurück, den ich nach der Ausführung der Mehtode benötige.
Z.B.: um Ihn anzuzeigen.

Wenn ich jetzt einen Thread mache, obwohl ich warten will und dann doch wieder auf den Thread warte habe ich irgenwie Bauchschmerzen bei dem Programmdesign...

[OldGrumpy]

Nach der diffusen Problembeschreibung würde ich das mal so grob aus dem Bauch heraus wie folgt lösen:

- TuWas wird über einen Dispatcher aufgerufen (dazu gleich mehr)
- Der Dispatcher sorgt dafür, dass TuWas nur von ihm aufgerufen wird und mittels CriticalSection oder passendem anderen Mechanismus wird verhindert, dass TuWas zweimal parallel laufen kann.
- Der Mauscursor wird am Anfang von TuWas auf Sanduhr gesetzt und als letztes in TuWas wieder normalisiert
- Aufrufe von TuWas werden nicht direkt über Buttonclicks o.ä. erledigt sondern als Aufrufe an den Dispatcher, der daraufhin einen weiteren Eintrag in seine Worklist macht statt TuWas direkt aufzurufen
- Über einen Timer wird in regelmäßigen Intervallen geprüft ob TuWas noch beschäftigt ist, ansonsten wird TuWas erneut gemäß den Daten in der Warteliste ein weiteres Mal aufgerufen, bis die Liste abgearbeitet ist. Danach kann der Timer deaktiviert werden bis ein erneuter Aufruf des Dispatchers für neue Arbeit für TuWas sorgt.

Wenn man es ganz ordentlich machen wollte, müsste das ganze noch etwas anders aussehen, indem das ganze komplett eventbasiert abläuft. Das erhöht aber wiederum die Gefahr von Deadlocks ganz enorm und bedarf sorgfältiger Vorplanung. Wenn ich mir die Beschreibung nochmal durchlese, so komme ich zu dem Schluss, dass - auch wenn der Auftrag nur "Programmerweiterung" heisst - das ganze nicht ohne Review der bestehenden Konstruktion laufen sollte. Man kann vieles umsetzen, nur ist nicht alles technisch machbare auch sinnvoll :)

[shmia]

Zitat:

Zitat von DelphiManiac

Delphi-Quellcode:

procedure TuWas;
begin
  // Prozedur tut was und hat einen exklusiven Zugriff auf eine Ressource
  // zwischendurch ruft sie Application.ProcessMessages auf
end;

Deine Procedure darf nicht einfach Application.ProcessMessages aufrufen!
Sie braucht einen Callback-Mechanismus, damit du genau steuern kannst, was passieren soll.

Delphi-Quellcode:

procedure TuWas(callback:TNotifyEvent);
begin
  // Prozedur tut was und hat einen exklusiven Zugriff auf eine Ressource
  // zwischendurch ruft sie den Callback auf
  for .... do
  begin
    if Assigned(callback) then callback(nil);
    // ....
  end;
end;

Das Callback kann als Procedure oder als Methode ausgeführt werden.
Ich habe hier mal eine Methode (TNotifyEvent) gewählt, weil ich mir gut vorstellen kann,
dass "TuWas" so komplex ist, dass man daraus eine Klasse machen müsste.