Thread (kein TThread) synchrinisieren?

[himitsu]

Ich hab eine Callbackfunktion, welche von einem Thread aus aufgerufen wurde.
Nun nöchte ich da din auf die Mainform zugreifen, wo es natürlich abundzu zu zu Exceptions kommt.

Hatte also versucht per Synchronize die Zugriffe auf die Form zu synchronisieren, was aber irgendwie nicht funktionieren wollte ... es kam vorwiegend sofort beim Aufruf von Synchronize zu den verschiedensten Exceptionen ala "Zugriffsverletzung bei Adresse soundso" :wall:

Dieses hätte mir eigentlich helfen sollen (wenn es gine) -.-''

Delphi-Quellcode:

class procedure Synchronize(AThread: TThread; AMethod: TThreadMethod); overload;

Delphi-Quellcode:

TThread.Synchronize(nil, MeineSynchronizeFunktion);
// eventuell auch, da nicht überladen (obwohl ersteres schon gehen sollte)
TThread.StaticSynchronize(nil, MeineSynchronizeFunktion);

Die interne Methode

Delphi-Quellcode:

procedure Synchronize(Method: TThreadMethod)

wollte ich ja umgehen, da diese ja nur innerhalb eines Threads funktioniert.


Wenn also jemand weiß mie man die Class-Funktionen anwendet, ohne in einer Exception zu landen bitte melden.
Also ohne eine TThread-Instanz ... theoretisch sollte es ja keine Probleme geben, wenn man NIL übergibt.

Notfalls wäre auch ein andere Weg akzeptabel.

Hatte auch schon versucht mich direkt in die SyncList (und ThreadLock ... siehe Classes.pas) einzuklinken, aber einen direkten Zugriff konnte ich nicht erreichen, ansonsten hätte ich mir etwas ähnliches wie das in der privaten Synchronize(ASyncRec: PSynchronizeRecord); zusammengebastelt :(


Hätte halt gern ein Mischung aus den beiden Testprogrammen erstellt, aber derzeit klappt das mit der Synchronisierung ja nicht.
In der Sync-Version wird im Moment jedesmal ein Thread erstellt, worin dann Syncronize aufgerufen und auf dessen Beendigung dann gewartet wird ... siehe Procedure DCStatusProc(Status: TDCStatus; Const Name: WideString; Value: LongInt); in .._SyncU.pas, welches auch die CallbackFunktion darstellt.



Ach ja, wen es inerresiert: die Testprogramme sind für 'ne Klasse, welche 2 Verzeichnisse miteinander vergleicht ('s is nun doch eine "Neuauflage" von CD's/Verzeichnisse vergleichen)

[shmia]

Du musst einfach eine benutzerdefinierte Message an dein Formular senden.

Delphi-Quellcode:

const UM_NOTIFY = WM_USER+101;

procedure DieCallbackprocedure(parameter:integer);
begin
   // schicke Message an eigenes Formular
   PostMessage(Form1.Handle, UM_PSS_INIT, parameter, 0);
end;

In deinem Formular wird dann die Message abgefangen und bearbeitet.
Du kannst der Message 2 Integer-Parameter übergeben; wenn du mehr brauchst, oder andere Datentypen,
muss man über eine Queue nachdenken.

[himitsu]

Ich hätte lieber eine "direkte" Methode ... hier müßte man ja unter Umständen Strings (alles über 8 Byte) länger zur verfügung stellen, oder auf eine Rückantwort warten, was bei 'ner übervollen Queue (der Form) auch länger dauern kann.

Wenn ich das z.B. über meinen USB-Stick rauschen lasse, dann wird die CallbackFunktion doch bestimmt locker 50.000-mal aufgerufen und "übermäßige" Wartezeiten bremsen das ganze halt aus.

Ist schön zusehen, wenn man beide Testprogramme (unter selben Bedingungen) über die selben Ordner jagt.

Mit einer Synchronisation in der CallbackFunktion braucht die Klasse halt nochmal "viel" länger.

[shmia]

Die Synchronize-Methode von TThread arbeitet auch mit Windows-Messages.

Delphi-Quellcode:

procedure TThread.Synchronize(Method: TThreadMethod);
begin
  FSynchronizeException := nil;
  FMethod := Method;
  SendMessage(ThreadWindow, CM_EXECPROC, 0, Longint(Self));
  // falls im Kontext des Hauptthreads eine Exception ausgelöst wurde
  // wird sie hier im Kontext ausgelöst
  if Assigned(FSynchronizeException) then raise FSynchronizeException;
end;

Dies scheint wirklich die einzige Technik zu sein, um mit einer VCL (sowie viele Windows API Funktionen) umzugehen, die nicht Threadsicher ist.
Auch COM/DCOM verwendet intern Windows-Messages beim Single-Appartment.

[Khabarakh]

Auch im .Net-Framework das gleiche:

Delphi-Quellcode:

public method Control.Invoke(method: Delegate): Object;

synchronisiert den aufrufenden Thread mit dem Thread des Controls, und zwar intern per SendMessage.
Dazu gibt es noch die asynchrone Version per Control.BeginInvoke, dann entsprechend per PostMessage.

Delphi-Quellcode:

public method Control.BeginInvoke(method: Delegate): IAsyncResult;

[himitsu]

Also die Klasse selber ist ja Threadsicher (jedenfalls die internen Funktionen, sowie die von außen aufrufbaren Klassenfunktionen) außer daß halt die CallbackFunktion absichtlich nicht mit den anderen Threads synchronisiert wird ... dieses muß man dann halt, wenn es wirklich nötig ist, innerhalb dieser CallbackFunktion machen.

In der 2. nichtsynchronen Version des Testprogramms hab ich ja einfach nur die entsprechenden Programmvariablen gelockt und dann wird abundzu über einen Timer (welcher ja synchron mit dem Hauptthread läuft) der Inhalt ausgelesen und angezeigt. Bei dieser Variante muß dann aber wirklich aufgepasst werden daß bestimmte Ereignisse nicht untergehen, da ja mehrere Callbackaufrufe innerhalb eines Timeraufrufs aufteten können.



Die VCL Synchronisiert sich ja auch über die selben Methoden wie TThread und darum wäre es mir halt lieber, wenn ich mich da ebenfalls mit einschleifen kann.

Und wie gesagt, eigentlich muß es möglich sein, daß man auch ohne ein TThreadObject die Synchronize-Funktion nutzen kann ... die haben ja nicht umsonst das CLASS davorstehen und ich bin mir sicher sowas auch schonmal irgendwo gesehen zuhaben (und da funktionierte es ja anscheinend).



Ich werd' jetzt erstmalnochein paar Tests versuchen. Mal sehn ob ich es doch noch irgendwie hinbekomm.
Ist nur blöd, daß sich Threads so "schwer" debuggen lassen :(


Ansonsten muß ich es wohl doch über Messages versuchen, wobei ich mich per CM_EXECPROC an ThreadWindow nicht wenden brauch, weil dafür ja ebenfalls eine TThread-Instanz benötigt wird und man dann auch gleich Synchronize intern aufrufen kann. :x

[himitsu]

OK, hab es soweit doch noch geschaft ^^

Es muß zwar immernoch eine Thread-Klasse erstellt werden, allerdings braucht diese nicht instantiiert zu werden :)

Die Klasse ist nun so definiert:

Delphi-Quellcode:

Type TSynchronizeThread = Class(TThread)
    Class Procedure DCStatusProc;
  End;

Und aufgerufen wird die Prozedur so:

Delphi-Quellcode:

TThread.Synchronize(nil, TSynchronizeThread.DCStatusProc);

Schade ist nur, daß man der Prozedur so keinen Parameter mitgeben kann -.-''