Funktion mit Paramtern in einem Thread

[Xerogon]

Hallo,
ich habe mich in letzter Zeit mit Threads beschäftigt und bekomme diese auch ohne Probleme zum laufen.
Das aber nur wenn meine Funktion keine Parameter erwartet. ich weiß nicht wie ich das lösen soll.

Mein Code:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

Function Test (a: Integer): Integer;
begin
  ShowMessage(IntToStr(a));
  Result := a;
end;



procedure TForm1.FormCreate(Sender: TObject);
var ID: Cardinal;
    Handle: THandle;
begin
  Handle := BeginThread(nil, 0, @Test(20), nil, 0, ID);  //geht nicht
  Handle := BeginThread(nil, 0, (@Test(20)), nil, 0, ID);  //geht auch nicht
end;

end.

Ich komm einfach nicht drauf :(

[implementation]

Hast du dir mal angeschaut, was die einzelnen Parameter für BeginThread bedeuten?

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  PInteger = ^Integer;
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

Function Test (a: PInteger): Integer;
begin
  ShowMessage(IntToStr(a^));
  Result := a;
end;



procedure TForm1.FormCreate(Sender: TObject);
var ID: Cardinal;
    Handle: THandle;
    I: Integer;
begin
  I := 20;
  Handle := BeginThread(nil, 0, @Test, @I, 0, ID);
end;

end.

So sollte es laufen.

[Xerogon]

Ohh nein. Bitte keine Zeiger :(

Naja, danke ;)

[Neutral General]

Zitat:

Zitat von implementation

So sollte es laufen.

Vom Prinzip her schon, aber das @I als Parameter zu übergeben kann/wird in die Hose gehen.

[blackfin]

uhm...ist bei BeginThread nicht der vierte Wert der Parameter?

Delphi-Quellcode:

....
var 
 a: Integer ;
......

a := 20 ;

Handle := BeginThread(nil, 0, @Test,@a, 0, ID);

Edit:
implementation war wohl schneller :mrgreen:

[Xerogon]

aber was wäre denn wenn ich mehr als ein Parameter angeben muss?
Der 5 Wert verlangt ja keinen Pointer, sondern einen Cardinalwert

[himitsu]

Einen Integer könnte man auch ohne Pointer (also einfach nur gecastet) übergeben

Bei mehr ist halt ein Pointer auf einen Record oder ein Datenobjekt nötig.


Wenn du sowas nicht willst, dann verwende TThread und übergib die Daten als Property oder im .Create als Parameter.

[implementation]

@ Neutral General:
Wieso bitte? Was soll das Problem sein? Genau das ist es doch, was BeginThread erwartet: ein Zeiger auf den Parameter.

@Xerogon:
Dann bastelst du dir ein Record, das alle Werte enthält und übergibst es.

@himitsu:
Theoretisch möglich, aber bei andern Typen wirds damit schwieriger.
// Edit: bezog sich auf den Cast.

[Xerogon]

Naja, irgendwann muss ich mich eh mal mit Zeiger beschäftigen :(
Ich hasse das, keine Ahnung warum.

[Neutral General]

@implementation: Das Problem ist, dass "I" nach dem Aufruf von TForm1.FormCreate nichtmehr gültig ist und von da an im Thread nicht mehr zu gebrauchen ist.

@Xerogon: Hab Pointer früher auch gehasst. Aber wenn man mal den Bogen raus hat, sind Pointer was tolles. Ich arbeite gerne mit Pointern :) :mrgreen:

[implementation]

@ Neutral General:
Mist, hast Recht - dann muss man das eben so machen:

Delphi-Quellcode:

unit Unit1; 

interface 

uses 
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, 
  Dialogs; 

type 
  PInteger = ^Integer; 
  TForm1 = class(TForm) 
    procedure FormCreate(Sender: TObject); 
  private 
    { Private-Deklarationen } 
  public 
    { Public-Deklarationen } 
  end; 

var 
  Form1: TForm1; 

implementation 

{$R *.dfm} 

Function Test (a: PInteger): Integer; 
begin 
  ShowMessage(IntToStr(a^)); 
  Result := a^; 
  Dispose(a);
end; 



procedure TForm1.FormCreate(Sender: TObject); 
var ID: Cardinal; 
    Handle: THandle; 
    I: PInteger; 
begin 
  New(I);
  I^ := 20;
  Handle := BeginThread(nil, 0, @Test, @I, 0, ID); 
end; 

end.

[Neutral General]

Jo so würd ichs bei Records machen. Aber bei kleineren Datentypen (<= 32 Bit) ist ein Cast auf einen Pointer einfacher.

Delphi-Quellcode:

Function Test (a: Integer): Integer; 
begin 
  ShowMessage(IntToStr(a)); 
  Result := a; 
end; 

procedure TForm1.FormCreate(Sender: TObject); 
var ID: Cardinal; 
    Handle: THandle; 
    I: Integer; 
begin 
  i := 20;
  Handle := BeginThread(nil, 0, @Test, Pointer(I), 0, ID); 
end;

[shmia]

Aus welchem Grund verwendest du nicht die Klasse TThread?
Damit wird doch Vieles einfacher. Die Übergabe von beliebigen Parametern ist dann sehr leicht möglich.

[Xerogon]

Ok, ich werde mit die Klasse mal genauer anschauen.

[Neutral General]

Der Nachteil ist, dass man extra eine Klasse von TThread ableiten muss. Das ist dann schon relativ aufwändig. Je nachdem wie viel ich in dem Thread mache und ob ich Synchronize brauche oder nicht benutze ich auch eher BeginThread.

[Xerogon]

Die Klasse kann ich in meiner Main Unit ableiten oder muss ich über Datei -> Neu ein neues Thread Object erstellen?

[sirius]

Ableiten reicht.

und procedure Execute überschreiben.

[shmia]

Zitat:

Zitat von Neutral General

Der Nachteil ist, dass man extra eine Klasse von TThread ableiten muss. Das ist dann schon relativ aufwändig.

Finde ich jetzt nicht.
Das Ableiten geht doch recht schnell und man braucht über die Windows-API im Prinzip nichts wissen (Abstraktion).
Ich gehe sogar soweit, dass ich Übergabeparameter im Bereich "public" anlege.
Nicht dass wir uns hier falsch verstehen, für wichtige Klassen werden verwende ich schon Properties.
Aber wenn die Klasse klein und einfach ist und es schnell gehen soll, dann spare ich mir die Tipparbeit.
Beispiel (frei erfunden)

Delphi-Quellcode:

// diese Klasse sucht in einer String-Liste nach dem höchsten Zahlenwert
TSucheHoechstenWert = class(TThread)
public
  Liste : TStrings;            // Eingabeparameter
  Ergwert : integer;           // Ausgabeparameter
  procedure Execute;override;  // ist normalerweise "protected"; nur zum Testen im Abschnitt "public"
end;

procedure TSucheHoechstenWert.Execute;
var
  i, wert : integer;
begin
  Assert(Assigned(Liste));  // zur Sicherheit prüfen ob Liste wirklich zugewiesen wurde
  Ergwert := -999999;
  for i:=0 to Liste.Count-1 do
  begin
    wert := StrToIntDef(Liste[i], -999999);
    if wert > Ergwert then Ergwert := wert;
  end;
end;

Und dann verwende ich noch einen weiteren Trick.
Threads sind üblicherweise schwer zu testen und schwer zu debuggen.
Deshalb lasse ich den Code zuerst ausserhalb des Threads ablaufen und prüfe damit
ob mein Code prinzipiell in Ordnung ist:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
   t : TSucheHoechstenWert;
begin
   t := TSucheHoechstenWert.Create(True); // Thread-Objekt erzeugt, Thread *nicht* starten
   t.Liste := Memo1.Lines;   // Übergabeparameter setzen
   t.Execute;                // Testen
   ShowMessageFmt('höchster Wert=%d',[t.Ergwert]);  // Ergebnis überprüfen
   t.Free;
end;

Hier wird die Thread-Klasse praktisch im Hauptthread ausgeführt.

[Xerogon]

Ich schreibe hier nochmal rein, da ich noch eine Idee hatte, diese aber nicht funktioniert.

Delphi-Quellcode:

Procedure Arbeit;
  Function Rechnen (a, b, c: Integer): Integer; //mehrere Paramter, die in einer Prozedure untergebracht werden
  begin
    Result := a + b + c;
  end;
begin
  Form1.Label1.Caption := IntToStr(Rechnen(20, 50, 60); //Funktion wird innerhalb der Prozedure aufgerufen
end;


Procedure Button1.Click...
var 
  ID: Cardinal;
  ArbeitHandle: THandle;
begin
  try
    ArbeitHandle := BeginThread(nil, 0, @Arbeit, nil, 0, ID); //Prozedur Arbeit wird aufgerufen 
    if ArbeitHandle = 0 then
      ShowMessage('Fehler beim Laden');
  finally
    CLoseHandle(ArbeitHandle);
  end;
end;

Es gibt keine Compilerfehler oder so. Das Programm friert nur ein und ich habe eine CPU auslastung von > 80% (Quadcore, 4x3Ghz)

[himitsu]

A: Hast du dir auch mal genau angesehn, wie BeginThread verwendet wird und vorallem wie die Thread-Prozedur deklariert sein muß?
Wenn du mit der WinAPI auf Kriegsfuß stehst, dann verwende TThread, welches diese Funktion kapselt.

B: Die VCL (Form1.Label1 und Co.) ist nicht thread-sicher und darf deßhalb niemals direkt von einem Threads aus aufgerufen werden.
Bei TThread kann man dazu Methoden wie Synchronize verwenden, um den Aufruf mit dem Hauptthread und der VCL zu synchronisieren.