Hallo,

ich habe schon bei Google und in diversen Foren gesucht, und auch Luckies Tutorial gelesen und die Demos angeschaut, aber irgendwie bekomme ich es nicht auf die Reihe

Zum Problem:

Ich habe zwei Forms.
Beim Erzeugen von Form1 wird Form2 miterzeugt.
Form1 wird angezeigt, Form2 soll noch nicht angezeigt werden.
Nachdem Form1 angezeigt worden ist, soll aus Form1 heraus ein Thread erzeugt werden, der eine Methode aus Form2 ausführt.
Form2.Methode greift dabei auf VCL-Objekte zu; aber nur auf welche, die auch auf Form2 liegen. Also auf ihre eigenen und nicht auf welche aus Form1!
Nach einem Klick auf einen Button auf Form1 soll dann Form2 angezeigt werden. Dabei bekomme ich dann den Fehler auf ein ungültiges Fensterhandle...

Ich weiß, dass man bei Zugriffen auf die VCL aus Threads heraus Synchronize benutzen soll.
Das verstehe ich auch insoweit, kann es nur nicht auf meine Situation anwenden.

Ich verstehe Synchronize so:
Aus Form1 wird ein Thread in Form2 aufgerufen, der auf VCL-Objekte in Form1 zugreifen soll.
Also ruft der Thread in Form2 mittels Synchronize eine Methode in Form1 auf, die den Zugriff auf das Objekt regelt.

In meinem Fall soll doch aber Form2 nur auf Objekte zugreifen, die auch auf ihr selbst liegen.

Ich vestehe nicht, wie ich da Synchronize nutzen soll.
Ist es nicht unsinnig, die Objekte, die auf Form2 liegen, in Form1 zu erzeugen?

Ich habe hier anscheinend eine echte Denkblokade, und würde mich freuen, wenn Ihr mir auf die Sprünge helfen könnt.

Vielen Dank!

Form1:

zusammenfalten · markieren

Delphi-Quellcode:

Procedure LoadData;
Begin
   Form2.LoadData;
End;

Procedure Form1.TuWas;
Begin
   oThread := BeginThread(nil, 0, Addr(LoadData), nil, 0, iID);
   ResumeThread(oThread);
   If oThread <> 0 Then Begin
      CloseHandle(oThread);
   End;
   GetExitCodeThread(oThread, iExit);
End;

Form2:

markieren

Delphi-Quellcode:

Procedure Form2.LoadData;
Begin
  //mache was mit VCL-Objekten
End;

Es ist egal, ob die Form sichtbar ist oder nicht. Und es ist auch egal wo du zeichnest. Entscheidend ist, dass du beim Zeichnen (Nutzung der VCL) auf globale Ressourcen zugreifst. Und dieser Zugriff muss synchronisiert werden (leider macht es die VCL nicht von alleine).

Dein Problem liegt imho daran, dass Du eine Thread-Routine mit Zugriffen auf grafische Elemente als Threadroutine übergibst. Das kann nicht klappen, da die VCL die Zugriffe im Kontext des Hauptthreads ausführt. Solche Zugriffe müssen innerhalb des Threads mit synchronize abgesichert werden.
Also musst Du solche Routinen deklarieren und da solltest Du dann eine TThread-Klasse für schaffen.

Übrigens steht ein Thread immer für sich alleine, egal wo er deklariert ist. Er kann also nicht zu Form1 oder Form2 gehören, selbst wenn er zufällig in derselben Datei deklariert ist. Solltest Du den Thread als Member der Klasse TForm2 deklariert haben, könnte das die Fehlermeldung verursacht haben.

Grüße, Messie

Zitat von sirius:

Es ist egal, ob die Form sichtbar ist oder nicht. Und es ist auch egal wo du zeichnest. Entscheidend ist, dass du beim Zeichnen (Nutzung der VCL) auf globale Ressourcen zugreifst. Und dieser Zugriff muss synchronisiert werden (leider macht es die VCL nicht von alleine).

Das habe ich schon verstanden.
Aber die Funktionen, die der Thread aufruft, zeichnen ja auf der gleichen Form, in der der Thread läuft.

@Messie
Und der Hauptthread ist in diesem Fall der aus Form1, also der, aus dem Form2 erzeugt wird?
Würde das bedeuten, dass ich die Objekte, die sich auf Form2 befinden sollen, doch in Form1 erzeugen muss?

Wie könnte soetwas denn aussehen?
Ich schreibe in Form2 eine Methode, in der ich eine Methode aus Form1 aufrufe, die dann die Objekte auf Form2 erzeugt?
Das ist doch von Hinten durch die Brust ins Auge.

Zitat von Pilloker:

Und der Hauptthread ist in diesem Fall der aus Form1, also der, aus dem Form2 erzeugt wird?
Würde das bedeuten, dass ich die Objekte, die sich auf Form2 befinden sollen, doch in Form1 erzeugen muss?

Nein, der HauptThread ist der, in dem das Programm läuft. Und da gehört die Erzeugung und Verwaltung aller VCL-Forms, Events etc. dazu. Ein von Dir zusätzlich erzeugtes Thread-Objekt ist wie ein zusätzliches unabhängiges Programm, was nicht auf die VCL-Elemente Deines Hauptprogramms zugreifen kann.

Grüße, Messie

Wenn du die Anzeigen auf Form2 partout in einem eigenen Thread machen willst, gibt es einen kleinen Trick, der dir vielleicht hilft: Man kann ein zweites (VCL)Formular im Kontext eines Threads mit Hilfe eines zusätzlichen Application-Objekts erzeugen und im Thread selbst die Nachrichtenwarteschlange abarbeiten. Das Formular ist dann komplett losgelöst vom Hauptthread und kann dann auch im eigenen Thread seine Controls aktualisieren etc.
Du kannst dann allerdings nicht direkt vom Hauptformular aus die entsprechende Methode im zweiten Formular aufrufen. Eine passende Windows-Nachricht schafft aber Abhilfe.
Hier ein Beispiel dazu :
Hauptformular

zusammenfalten · markieren

Delphi-Quellcode:

interface

{...}

type
  TFormThread = class (TThread)
  private
    FApplication : TApplication;
  protected
    procedure Execute; override;
  public
    FForm : TForm2;
    procedure OnNotify (Sender : TObject);
  end;

  TForm1 = class(TForm)
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  private
    FFormThread : TFormThread;
    FTerminateByClose : Boolean;
    procedure OnTerminate (Sender : TObject);
  end;

{...}

implementation

{...}

{TForm1}

procedure TForm1.FormCreate(Sender: TObject);
begin
  FTerminateByClose := False;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  if not Assigned (FFormThread) then
  begin
    FFormThread := TFormThread.Create(True);
    FFormThread.FreeOnTerminate := True;
    FFormThread.OnTerminate := OnTerminate;
    FFormThread.Resume;
  end;
end;

procedure TForm1.OnTerminate(Sender: TObject);
begin
  if not FTerminateByClose then
    FFormThread := nil;
end;

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  If Assigned (FFormThread) then
  begin
    FTerminateByClose := True;
    SendMessage (FFormThread.FForm.Handle, WM_CLOSE, 0, 0);
    FFormThread.FreeInstance;
    FFormThread := nil;
  end;
  Action := caFree;
end;

{ TFormThread }

procedure TFormThread.Execute;
begin
  FApplication := TApplication.Create(nil);
  try
    FApplication.Initialize;
    FForm := TForm2.Create(FApplication);
    FForm.OnNotifyParent := OnNotify;
    FForm.Show;
    while (not Terminated) do
    begin
      Sleep (1);
      FApplication.ProcessMessages;
    end;
    FApplication.ShowHint := False;
    FApplication.Destroying;
    FApplication.DestroyComponents;
  finally
    FreeAndNil (FApplication);
  end;
end;

procedure TFormThread.OnNotify(Sender: TObject);
begin
  Terminate;
end;

Formular2 :

zusammenfalten · markieren

Delphi-Quellcode:

interface

{...}

type
  TForm2 = class(TForm)
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  private
    FOnNotify : TNotifyEvent;
  public
    property OnNotifyParent : TNotifyEvent read FOnNotify write FOnNotify;
  end;

{...}

implementation

{TForm2}

procedure TForm2.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  Action := caHide;
  if Assigned (FOnNotify) then
    FOnNotify(Self);
end;

Mit dem Button in Formular1 wird das zweite Formular erzeugt und angezeigt.

Ich verstehe es einfach nicht.

Ich starte nun von Form1 aus einen Thread, der eine Methode in Form2 aufruft.
Diese erzeugt dann VCL-Objekte usw.

Wie mache ich das denn nun mit dem Synchronize? Ich muss in Form2 mit Synchronize irgendetwas aufrufen, was woanders liegt (wo?) und mir dann die VCL-Objekte erzeugt?

Die Beispiele in Luckies Demos leuchten mir ein, aber hier komme ich einfach nicht weiter

Hi!

Zitat:

Das habe ich schon verstanden.
Aber die Funktionen, die der Thread aufruft, zeichnen ja auf der gleichen Form, in der der Thread läuft.

Der Thread läuft in keinem Form. Deine Forms laufen im Haupt/VCL-Thread, das ist einer. Und dann gibt es noch deinen eigenen, erstellten Thread. Egal wo er deklariert ist oder gestartet wird, er läuft einfach immer neben dem VCL-Thread und neben anderen eventuell vorhandenen Threads. So könnte das, was du brauchst, aussehen (einfach mal so niedergeschrieben, ohne Test):

zusammenfalten · markieren

Delphi-Quellcode:

type
  MeinForm = class(TMeinForm)
    lblThreadText: TLabel;
  private
    procedure StarteDenThread;
  end;

type
  Thread = class(TThread)
  private
    Form: TMeinForm;
    procedure MachVCLSachen;
  protected
    procedure Execute; override;
  public
    constructor Create(Form: TMeinForm);
  end;

procedure MeinForm.StarteDenThread;
begin
  Thread.Create(Self);
end;

constructor Thread.Create(Form: TMeinForm);
begin
  inherited Create(False);
  Self.Form := Form;
end;

procedure Thread.Execute;
begin
  // Kram machen
  Synchronize(MachVCLSachen);
  // Kram machen
end;

procedure Thread.MachVCLSachen;
begin
  Form.lblThreadText := 'Der Thread lässt grüßen!';
end;

Mir fällt gerade auf, du erstellst den Thread ja per BeginThread. Synchronize ist eine Methode von TThread. Wenn du nicht TThread benutzen möchtest, müsstest du dir vermutlich einen eigenen Synchronisierungsmechanismus bauen.

Kleiner Nachtrag, weil du durch den Thread VCL-Objekte erzeugen möchtest: Dir ist aber schon klar, dass Synchronize die Befehle an den Haupt-Thread weiterleitet, diese *nicht* in deinem eigenen Thread ausgeführt werden, und das Form dadurch beschäftigt ist/geblockt wird, oder? Wenn du nur VCL-Dinge über den Thread erzeugen möchtest, wäre der Thread an der Stelle absolut überflüssig. Das nur noch nebenbei.

in deinem Beispiel müsstest du einfach Form2.Loaddata synchronisieren, was

1. nicht sinnvoll ist (gesamten Thread synchronisieren)
2. nicht möglich ist, da du nicht TThread benutzt

Wenn Loaddata so lange dauert liegt es sicher nicht an der Erstellung von VCL-Objekten sondern an anderen datentechnischen Sachen. Hier gilt erstmal Daten von Anzeige zu trennen. Dann kannst du erst die Daten laden und daraufhin die Anzeige gestallten. Und das Laden kannst du in einen Thread auslagern.

Zitat von Pilloker:

Ich starte nun von Form1 aus einen Thread, der eine Methode in Form2 aufruft.

Der Thread bekommt eine abzuarbeitende Methode übergeben. Die mag in Form2 stehen, ist aber die Thread-Methode. Das ist kein Aufruf, sondern der Thread selbst. Alles andere muss in untergeordneten Routinen stehen. Werden diese mit synchronize aufgerufen, können dort auch VCL-Objekte erzeugt werden. Aber nicht im Thread selbst.

Grüße, Messie