PostMessage & Thread (Verständnisfrage)

[RB]

Hallo,

ich habe mal ne Verständnisfrage (also nicht lachen *gg*). Ich schreibe ein Projekt mit mehreren
Formularen. In einem der vielen Formulare habe ich gleich längere Prozedur
gleich in dem Ereignis FormShow stehen. Die Abarbeitung der Prozedur dauert
ca. 10 Sekunden und während diesen 10 Sekunden wird das Formular noch nicht
gezeichnet. Bis dahin verhält sich das ja alles noch normal. Ich möchte es
erreichen das mein fenster angezeigt wird und in FormShow trotzdem schon die
Prozedur beginnt. Dazu habe ich mir eine Message geschrieben und diese
Message mit Postmessage losgeschickt! Das ganze läuft ;-). Nun aber meine
Frage: Wenn ich die Message losschicke wird meine Prozedur abgearbeitet und
das Programm läuft sofort weiter (beleibt also nicht bei FormShow stehen).
Ist dieses Posten der Message ein Thread??? Oder so etwas in der Richtung.
Es werden ja zwei Dinge gleichzeitig gemacht? Würde mich mal interessieren?

Gruß Rainer

[Andreas Kosch]

Hallo,

>Ist dieses Posten der Message ein Thread?

Nein.

>Es werden ja zwei Dinge gleichzeitig gemacht?

Nein - denn der Aufruf von PostMessage sorgt nur dafür, dass diese Botschaft ans Ende der Botschaftswarteschlange einsortiert und erst dann dem Formular zugestellt wird, wenn das Formular keine anderen (wichtigeren) Botschaften abarbeiten muss. Für den Benutzer sieht es nur so aus, als ob 2 Sachen gleichzeitig gemacht werden, da die Botschaft erst dann greift, wenn FormShow vollständig abgearbeitet wurde und somit das Formular vollständig sichtbar ist. Den Einsatz eines richtigen Threads demonstriert das folgende Beispiel:

<b>Langwierige Formular-Initialisierung in einen Thread auslagern</b>

Der Thread aktualisiert im Beispiel ein TProgressBar-Anzeige im Hauptformular, wobei nach jeder Erhöhung über Sleep(25) eine Ruhepause von 25 Millisekunden eingelegt wird. Der Thread bleibt bis zum Programmende erzeugt (auch wenn er nichts mehr ausführt).

<b>Thread-Unit</b>
<pre>
{ ************************************************** **************
Source File Name : Smart_Thread.PAS
Typ : Thread-Unit
Autor : Andreas Kosch
Erstellt am : 13.11.1998
Compiler : Delphi 4.01 UpdatePack #1
Betriebssystem : Windows 95
Revisionen : Auslagern von zeitintensiven Initialisierungen
in einen Thread, damit das Hauptformular
schnell bedienbar ist.
************************************************** ************** }

unit Smart_Thread;

interface

uses
Windows, Messages, SysUtils, Classes, ComCtrls;

type
TOnCreateThread = class(TThread)
private
FValue : Integer;
FProgress : TProgressBar;
procedure UpdateProgress;
procedure HideProgress;
protected
procedure Execute; override;
public
constructor Create(aProgress: TProgressBar);
end;

implementation

{ TOnCreateThread }

constructor TOnCreateThread.Create(aProgress: TProgressBar);
begin
FProgress := AProgress;
inherited Create(False);
end;

procedure TOnCreateThread.Execute;
begin
while (not Terminated) and (FValue <= 100) do
begin
Synchronize(UpdateProgress);
Inc(FValue);
// Wartepause zur Demonstration einlegen
Sleep(50);
end;
Synchronize(HideProgress);
end;

procedure TOnCreateThread.UpdateProgress;
begin
FProgress.Position := FValue;
end;

procedure TOnCreateThread.HideProgress;
begin
FProgress.Visible := False;
end;

end.
</pre>
<b>Beispielprogramm</b>

Beim Beenden des Programms müssen zwei Fälle beachtet werden:<br>
a) Programm wird geschlossen, obwohl der Thread noch läuft <br>
b) Programm wird geschlossen, wobei der Thread nichts mehr ausführt (Execute ist abgeschlossen) <br>
Aus diesem Grund wird in der Ereignisbehandlungsmethode <b>OnDestroy</b> zuerst <b>TThread.Terminate</b> und anschließend <b>TThread.WaitFor</b> aufgerufen.
<pre>
{ ************************************************** **************
Source File Name : SmartTestFrm.PAS
Typ : Hauptformular-Unit
Autor : Andreas Kosch
Erstellt am : 13.11.1998
Compiler : Delphi 4.01 UpdatePack #1
Betriebssystem : Windows 95
Revisionen : Auslagern von zeitintensiven Initialisierungen
in einen Thread, damit das Hauptformular
schnell bedienbar ist.
************************************************** ************** }

unit SmartTestFrm;

interface

uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
ComCtrls, Smart_Thread, StdCtrls, Buttons;

type
TFormMain = class(TForm)
StatusBar1: TStatusBar;
ProgressBar1: TProgressBar;
BitBtnHelp: TBitBtn;
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure BitBtnHelpClick(Sender: TObject);
private
{ Private-Deklarationen}
FOnCreateThread : TOnCreateThread;
public
{ Public-Deklarationen}
end;

var
FormMain: TFormMain;

implementation

{$R *.DFM}

procedure TFormMain.FormCreate(Sender: TObject);
begin
FOnCreateThread := TOnCreateThread.Create(ProgressBar1);
end;

procedure TFormMain.FormDestroy(Sender: TObject);
begin
if Assigned(FOnCreateThread) then
begin
FOnCreateThread.Terminate;
FOnCreateThread.WaitFor;
end;
end;

procedure TFormMain.BitBtnHelpClick(Sender: TObject);
begin
ShowMessage('Trotz noch laufender Initialisierung bedienbar!');
end;

end.
</pre&gt

[RB]

Danke Andreas. Das war wie immer sehr gut und sehr ausführlich ;-)

Gruß Raine