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

zusammenfalten · markieren

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.

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

zusammenfalten · markieren

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;

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.

Ok, ich werde mit die Klasse mal genauer anschauen.

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.

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

Ableiten reicht.

und procedure Execute überschreiben.

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)

zusammenfalten · markieren

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:

markieren

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.

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

zusammenfalten · markieren

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)

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.