Hallo,

beim Umstellen eines Programms von Methoden auf Stored Procedures soll das ganze in einen Thread gepackt werden. Die SP sind komplex und zeitaufwendig, bisher wurden diese von der Mainform übernommen. Dabei gab es dann ein Infofenster mit einer Pseudoprogressbar die signalisiert das etwas in Arbeit ist. Bei der Umstellung auf SP friert nun dieses Infofenster ein. Lösung: Auslagerung in Thread.

Ist der nachfolgende Ansatz so richtig oder was ist noch zu beachten. Geht er vielleicht einfacher?

Danke schon mal....

zusammenfalten · markieren

Delphi-Quellcode:

  TMachWasLangesInDerDBThread = class(TThread)
    private
      fSPQuery : TIBQuery;
      fInProgress : Boolean;
    protected
      procedure Execute(); override;
    public
      constructor create(const aPKey,aTKey:TKey; aChildLevel:Integer);
      destructor Destroy; override;

      property InProgress : Boolean read fInProgress;
  end;

constructor TMachWasLangesInDerDBThread.create(const aPKey,aTKey:TKey; aChildLevel:Integer);
begin
  inherited create(False);
  FreeOnTerminate := False;

  fInProgress := True;

  fSPQuery := TIBQuery.Create(nil);
  try
    fSPQuery.SQL.Text:='EXECUTE PROCEDURE P_SORT...';
    fSPQuery.ParamByName(...);
  except
    on e: exception do
    begin
      showmessage(e.Message);
    end;
  end;
end;

destructor TMachWasLangesInDerDBThread.Destroy;
begin
  if Assigned(fSPQuery) then
  begin
    fSPQuery.Free;
  end;

  inherited destroy;
end;

procedure TMachWasLangesInDerDBThread.Execute;
begin
  try
    fSPQuery.ExecSQL;
  except
    on e: exception do
    begin
      showmessage(e.Message);
    end;
  end;
  fInProgress := False;
end;

.... im Hauptprozess Aufruf durch...

...
MeinInfoFenster.show;

aMYThread := TMachWasLangesInDerDBThread.create(...);
try
  while aMYThread.InProgress do
  begin
    MeinInfoFenster.Action;
    Sleep(1000);
  end;
finally
  aMYThread.Free;
end;
...

Ist die verwendete DB-Komponente Thread-Save?
D.h. darfst du von unterschiedlichen Query-Komponenten auf eine einzige Connection-KOmponente zugreifen?
Falls nicht musst du in jedem Thread eine eigene DB-Verbindung aufbauen.

das wäre nicht das Problem, ich kann ja die Entsprechenden Infos aus dem Hauptthread übergeben.

Was mir mehr sorgen macht, ist...

markieren

Delphi-Quellcode:

while aMYThread.InProgress do
begin
  MeinInfoFenster.Action;
  Sleep(1000);
end;

was ist wenn das durch ein Fehler zu einer Endlosschleife wird? Wie kann ich das vielleicht anders lösen?

Wie wäre es ohne sleep aber mit Triggerung durch einen Timer?
oder so:

markieren

Delphi-Quellcode:

while aMYThread.InProgress do
begin
  aMyThread.InProgres:=false; {ich hab das read gesehen.....}
  MeinInfoFenster.Action;
  Sleep(1000);
end;

Gruß
K-H

Warum kann Sleep nicht endlich aus der RTL rausgeworfen werden?

Deutlich besser ist WaitForSingleObject, dann lässt sich die "Wartepause" auch abbrechen (sonst z.B. nervig wenn bei Programmende einige Threads noch die eine oder andere Sekunde schlafen, beim System runterfahren, wenn man einfach nur abbrechen will...). Zum Beispiel mit einem Event (auf den man damit wartet).

Wird das Query wirklich im Thread ausgeführt. Denn wenn die Komponente in TThread.create erstellt wird, gehört sie zumindest noch dem Mainthread (müsste man überprüfen, wie die Komponente arbeitet.

Ansonsten: sleep vermeiden, steht ja schon da.


Edit:

Zitat von NickelM:

Ich persönlich find es blöd, da die Hauptanwendung im Endeffekt wieder einfriert.

Sieht ja so aus, als ob das notwendig ist. Stichwort Splashscreen und Vorarbeiten beim Start.

Lass das mit Sleep und so weg, und mach eine Synchronize-Funktion am Ende das Thread, wo du fInProgress := False; hast. Damit sind beide Threads (Haupthread, also dein Fenster, und dein "Arbeiterthread") unabhängig von einander. Das mit ShowMessage im except würd ih ändern. Dass könnte unter umständen mal knallen. Verwende lieber MessageBox von Windows. Ist sicherer und bietet mehr

Nachtrag, wegen anderen Posts : Oder mit WaitForSingleObject, wie schon erwähnt . Ich persönlich find es blöd, da die Hauptanwendung im Endeffekt wieder einfriert.

Gruß NickelM

@ChrisE : Er meinte, wie ich das mit meinem Post bezüglich Synchronize meinte.
@ibp : Okay hab mich zugegeben bischen doff ausgedrückt. Ich meinte, dass du das alles ein bischen anders aufbauen kannst, und somit kein Sleep oder sonstiges mehr brauchst.

zusammenfalten · markieren

Delphi-Quellcode:

  
TMachWasLangesInDerDBThread = class(TThread)
    private
      ...
      FErrorMsg : String; //Da man keine Funktion mit Parameter synchronizieren kann
      procedure OnErrorDo;
      procedure OnFinishDo;
    protected
      procedure Execute; override;
    public
   ...
  end;

procedure TMachWasLangesInDerDBThread.Execute;
begin
  try
    fSPQuery.ExecSQL;
  except
    on e: exception do
    begin
      FErrorMsg := e.Message;
      Synchronize(OnErrorDo);
      Terminate; //Zur Sicherheit
    end;
  end;
  Synchronize(OnFinishDo);
  Terminate; //Zur Sicherheit
end;

procedure TMachWasLangesInDerDBThread.OnErrorDo;
begin
  ShowMessage(FErrorMsg);
  //OnFinishDo; oder was du beim Error sonst nach alles gemacht hättest.
end;

procedure TMachWasLangesInDerDBThread.OnFinishDo;
begin
  //z.b. MeinInfoFenster.hide; oder was du nach deiner Schleife gemacht hättest
end;

.... im Hauptprozess Aufruf durch...

...
MeinInfoFenster.show;
aMYThread := TMachWasLangesInDerDBThread.create(...);
aMYThread.FreeOnTerminate := True;

So habe ich dass immer gelöst, wenn ich auf einen Thread warten musste. Damit bleibt das Fenster, wenn überhaupt, nur beim Synchronize-Teil kurz hängen, da beide Thread ja zusammen arbeiten.

Gruß NickelM

Ich verwende einen Connectionpool, der mir TIBDatabase-Componenten bereit hält.

Die Threads haben eine lokale im Thread erzeugte TIBStoredProc-Instanz. Beim Ausführen fordern sie eine Connection an, weisen sie der SP zu, führen sie aus und geben die Connection wieder an den Pool zurück.

Der Pool verwaltet nur eine TThreadList if TIBDatabase. Wenn eine Verbindung angefordert wird, aber die Liste leer ist, wird eine neue erstellt.

Keine Ahnung, ob das sinnig ist, aber ich habe es mal so umgesetzt und das läuft sehr gut. Ich verwende das für eine Datenpumpe, wobei die Threads als Workerthread fungieren.

Ich würde außerdem zusehen, das die SP nicht allzulange braucht. Wenn sie das tut, hast Du vermutlich etwas falsch gemacht.