BeginThread - Methoden aufruf

[youuu]

Hi,

ich möchte eine Procedure mit BeginThread aufrufen, habe aber noch Probleme.

Delphi-Quellcode:

MyClass:= TMyClass.Create; // Klasse erstellt.

FThreadHandle := BeginThread(nil, 0, @MyClass.Scan(o), Pointer(Self), 0, ThreadID); // Aufruf

Jedoch sagt er mr immer "Variable erforderlich" nach

Delphi-Quellcode:

@MyClass.Scan(o)

[Björn Ole]

Gibt denn MyClass.Scan(o) einen Funktionszeiger zurück?
BeginThread erwartet dort nämlich eine "einfache Funktion", keine Methode.

Delphi-Quellcode:

function ThreadFunc(Parameter: Pointer): Integer;

[youuu]

Ah, das war eine Metode, es funktionieren aber nur Functionen?

Aber selbst bei einer funktion, erhalte ich diesen Fehler.

Delphi-Quellcode:

function TMyClass.Scan(Kat: Integer): Integer;

[SirThornberry]

Könntest du deinem Thema bitte einen aussagekräftigeren Titel geben? Danke :)

[Björn Ole]

Keine Methode (Function/Procedure einer Klasse) benutzen, sondern:

Delphi-Quellcode:

function Blub(Parameter: Pointer): integer;
begin
  // ...
end;

// Aufruf
BeginThread(nil, 0, Blub, nil, 0, ThreadID);

[youuu]

Ok nun verstehe ich es.

Was ist denn die beste Möglichkeit eine Procedure einer Klasse als Thread auf zu rufen?

1. Klasse ist schon created
2. es muss nur eine bestimmte Procedure der klasse abgearbeitet werden im Thread.

[lbccaleb]

Wenn mich nicht alles täuscht muss man doch auf die function zeigen?? also

Delphi-Quellcode:

function Blub(Parameter: Pointer): integer;
begin
  // ...
end;

// Aufruf
BeginThread(nil, 0, [COLOR="Red"]@[/COLOR]Blub, nil, 0, ThreadID);

oder nicht??

[youuu]

Was michauch irritiert, hier wird eine procedure verwendet.

hier

[Björn Ole]

lbccaleb, geht beides.

So mit einer Methode:

Delphi-Quellcode:

TClass = class
public
  class procedure Blub(Param: Pointer); static;
end;

// Aufruf:
with TClass.Create do
  BeginThread(nil, 0, @Blub, nil, 0, ThreadID);

Ob das so aber vernünftig ist, weiß ich nicht.

Add: SirThornberry und himitsu erklären das im oben genannten Thread wunderprächtig. Ob nun eine function oder procedure übergeben wird, ist im Endeffekt egal.

[youuu]

Hm, dann habe ich dieses Problem

Instanzenelement 'FslKat' in diesem Zusammenhang nicht verfügbar //FslKat ist eine StringList aus der Klasse im privat Bereich

[Björn Ole]

Siehe http://www.delphipraxis.net/1032983-post3.html

Zitat:

Zitat von himitsu

> statische (static) Klassen-Methode: Self gibt's nicht

Darum kannst du auch nicht auf die Felder deiner Klasse zugreifen.


Weitere Möglichkeit, allerdings darf hier die Methode, die du BeginThread übergibst, keine Parameter entgegennehmen, da dieser vom unsichtbaren "Self" belegt wird.

Delphi-Quellcode:

TClass = class
public
  class procedure Blub;
end;

var
  ThreadID: Cardinal;
  p: procedure of object;
begin
  with TClass.Create do
    p := Blub;
  BeginThread(nil, 0, p, nil, 0, ThreadID);

[youuu]

Was gäbe es für eine Möglichkeit ohne BeginThread?
Denn diese scheint mir sehr suboptimal, für mein Problem.

Ich muss diese Methode

Delphi-Quellcode:

MyClass.Scan(o);

in einen Thread abarbeiten lassen, nur wie?
Der Parameter muss unbedingt übergeben werden, sowie aus der Klasse entsprechende Variablen benutzbar bleiben.

[Björn Ole]

• die Scan-procedure in eine einfache, globale procedure auslagern
• die benötigten Daten aus der Klasse inkl dem Parameter (o) in ein entsprechendes Record kopieren
• BeginThread einen Zeiger auf dieses Record übergeben und in der ThreadProc dann mit dem Record arbeiten

Solltest du das so umsetzen, würde ich dir empfehlen, dir davor mal TThread anzuschauen, damit geht das mMn einfacher.

[youuu]

TThread kenn ich, nur hab ich dort das Problem gehabt, das ich nicht weiß wie ich die methode dort aufrufe ohne sie extra neu zu createn, da der Thread sie sonst nicht erkennt.

[Björn Ole]

Den Inhalt deiner TMyClass.Scan kopierst du einfach in die Execute-Methode deines TThreads. Zusätzlich spendierst du dem TThread noch die benötigten Felder aus TMyClass, mit denen dann der TThread arbeitet. Die Felder füllst im constructor oder über properties o.ä.

[himitsu]

Selbst wenn die Klassen-Methode nicht statisch (static) ist, dann gibt es keine Felder, auf welche man zugreifen kann.

Eine Klassenmethode würd über die Klasse aufgerufen,
in soeinem Fall steckt in Self natürlich nur ein Klassenzeiger.
Normale Methoden werden über ein Objekt aufgerufen und enthalten dann in Self den Objektzeiger.

Von einer Klassen-Methode kann man also niemals auf die Felder eines Obektes zugreifen.

Lösung:
Übergib BeginThread eine Procedur oder eine statische Klassen-Methode und den Instanzzeiger zum Objekt, als Parameter.
Innerhalb dieser Prozedur/StaticMethod rufst du dann eine Objekt-Methode auf.
PS: TThread macht es intern auch nicht groß anders.

Oder nutze TThread und leite deine Klasse davon ab.

PS: Für sowas hatte ich auch mal mit wasrumgespielt:
http://www.delphipraxis.net/152311-t...en-lassen.html
Bzw. siehe die Links in Post #2 und #3.

[sx2008]

Zitat:

Zitat von youuu (Beitrag 1045821)

TThread kenn ich, nur hab ich dort das Problem gehabt, ...

Ich habe dein Problem jetzt nicht wirklich verstanden, aber ich kann dir nur den Rat geben weiterhin bei TThread zu bleiben.

Du verhältst dich wie ein C-Programmierer, der ein Problem mit der Sprache "C" hat und dann meint er könnte das viel einfacher in Assembler lösen.
Was für ein Holzweg!
Es ist immer einfacher auf einem höheren Abstaktionslevel (wie es die Klasse TThread darstellt) zu programmieren als in die tieferen Schichten (Windows API, BeginThread,...) vorzustossen.
Du kannst mit der Klasse TThread alles machen was du in Bezug auf Multithreading brauchst; es gibt keinen Grund (ausser Neugier/Wissensdurst) sich in den tieferen Ebenen "die Finger schmutzig zu machen".

[Luckie]

...weil du mit eine Klassen Prozedur einer Klasse keinen Zugriff auf die anderen Elemente einer Klasse hast. Klassen Prozeduren funktionieren ohne eine Instanz der Klasse.

[littleDave]

Mit ein paar Tricks kann man auch Methoden mit Parametern, ohne "große" Probleme bekommen.

Delphi-Quellcode:

interface

type
  // Event-Deklaration, die in der Klasse aufgerufen wird
  TThreadExecuteEvent = procedure(const Params: array of const) of object;

procedure RunInThread(Meth: TThreadExecuteEvent; const Params: array of const); register;

implementation

type
  // interne Daten
  TConstArray = array of TVarData;
  PConstArray = ^TConstArray;

  PExecutionInfo = ^TExecutionInfo;
  TExecutionInfo = packed record
    EntryPoint    : TThreadExecuteEvent;
    ArrayLen      : integer;
    Params        : PConstArray;
  end;

// Dass ist die Methode, die man bei "BeginThread" aufruft, als Parameter bei "BeginThread" 
// kommt dann der Pointer auf ein TExecutionInfo - record 
function __internThreadProc(ExecInfo: PExecutionInfo): integer; stdcall;
var pPtr   : Pointer;
    pSelf  : Pointer;    
    pBase  : Pointer;
    len    : integer;
begin
  try
    // Start Address of the method
    pPtr  := TMethod(ExecInfo^.EntryPoint).Code;
    // Self-Pointer
    pSelf := TMethod(ExecInfo^.EntryPoint).Data;
    // Parameter array
    pBase := ExecInfo^.Params;
    // length of Parameter
    len   := ExecInfo^.ArrayLen;
    asm 
      // save base registers
      push ecx
      push ebx
      push eax

      // push self ptr
      mov  eax, pSelf
      // push array of const
      // array of const ->
      //  1st the pointer to the 1st element of the array
      mov  ebx, pBase
      //  2nd (hidden parameter): high value of the array
      mov  ecx, len

      // call
      call pPtr

      // restore registers
      pop eax
      pop ebx
      pop ecx
    end;
  finally
    // ExecInfo freigeben (wurde von "CallMethod" erzeugt)
    Dispose(ExecInfo);
  end;
  result := 0;
end;

procedure RunInThread(Meth: TThreadExecuteEvent; const Params: array of const); 
var p: PExecutionInfo;
begin
  // p wird in der Methode "__internThreadProc" wieder freigegeben
  New(p);
  p^.EntryPoint := Meth;
  p^.ArrayLen   := High(Params);
  p^.Params     := PConstArray(@Params);

  // hier der BeginThread - Aufruf:
  //  BeginThread(nil, 0, @__internThreadProc, p, 0, ThreadID);
  
  // Test-Code: direkter Aufruf
  __internThreadProc(p);
end;

Hier mal ein kleines Beispiel zur Benutzung:

Delphi-Quellcode:

type
  TTest = class
  private
    FValue : string;
  public
    procedure Test(const Params: array of const);
  end;

{ TTest }

procedure TTest.Test(const Params: array of const);
begin
  // Test des Self-Pointers
  ShowMessage(FValue);
  // Test auf Länge des Params-Array
  ShowMessage(IntToStr(length(Params)));
  // Ausgabe des 1. Parameters
  ShowMessage(IntToStr(TVarRec(Params[0]).VInteger));
end;

procedure TForm1.Button1Click(Sender: TObject);
var t: TTest;
begin
  t := TTest.Create;
  try
    t.FValue := 'Hallo';
    RunInThread(t.Test, [12345, 15676]);
  finally
    // wichtig: für das Testen wird kein Thread erstellt
    // daher können wir im finally-Part auch das Objekt wieder freigeben.
    // Falls man nun wirklich die Sache in einem Thread ausführt, darf
    // das Objekt erst freigegeben werden, wenn der Thread beendet ist - also nicht
    // hier.
    t.Free;
  end;
end;

Das ganze ist nur als Denk-Anstoß gedacht.

Gruß

EDIT
Ich seh gerade, dass das ganze per Threading noch nicht so ganz läuft: der Hacken ist in der Methode "RunInThread" in der Zeile:

Delphi-Quellcode:

p^.Params := PConstArray(@Params);

. Beim direkten Aufruf (also der Testcode), fällt der Fehler noch nicht auf. Jedoch wenn man es per Threading macht: das array-of-const wird freigegeben, sobald die Methode verlassen wird. Jedoch ist der Thread mit 99%er wahrscheinlich noch nicht beendet, d.h. der Pointer auf das "array-of-const"-Array wird ungültig. Man müsste das Array in der Methode neu kopieren - aber darauf habe ich gerade keine Lust mehr :P. Außerdem ist es wirklich etwas übertrieben. Hier mal eine einfache "RunInThread"-Methode, die ein beliebiges Objekt als Parameter entgegen nimmt (damit sollte es relativ einfach sein, das Grundprinzip zu verstehen):

Delphi-Quellcode:

interface

procedure RunInThread(Meth: TNotifyEvent; const Params: TObject); 

implementation

type
  // interne Daten
  PExecutionInfo = ^TExecutionInfo;
  TExecutionInfo = packed record
    EntryPoint    : TNotifyEvent;
    Data          : TObject;
  end;

// Dass ist die Methode, die man bei "BeginThread" aufruft, als Parameter bei "BeginThread" 
// kommt dann der Pointer auf ein TExecutionInfo - record 
function __internThreadProc(ExecInfo: PExecutionInfo): integer; stdcall;
begin
  try
    ExecInfo^.EntryPoint(ExecInfo^.Data);
  finally
    // ExecInfo freigeben (wurde von "CallMethod" erzeugt)
    Dispose(ExecInfo);
  end;
  result := 0;
end;

procedure RunInThread(Meth: TThreadExecuteEvent; const Data: TObject); 
var p: PExecutionInfo;
begin
  // p wird in der Methode "__internThreadProc" wieder freigegeben
  New(p);
  p^.EntryPoint := Meth;
  p^.Data       := Data;

  // hier der BeginThread - Aufruf:
  //  BeginThread(nil, 0, @__internThreadProc, p, 0, ThreadID);
  
  // Test-Code: direkter Aufruf
  __internThreadProc(p);
end;

Noch ein Beispiel

Delphi-Quellcode:

type
  TTest = class
  private
    FValue : string;
  public
    procedure Test(Sender: TObject);
  end;

{ TTest }

procedure TTest.Test(Sender: TObject);
begin
  // Test des Self-Pointers
  ShowMessage(FValue);
  // Test des Parameters
  ShowMessage(TTest(Sender).FValue);
end;

procedure TForm1.Button1Click(Sender: TObject);
var t: TTest;
begin
  t := TTest.Create;
  try
    t.FValue := 'Hallo';
    RunInThread(t.Test, t);
  finally
    // wichtig: für das Testen wird kein Thread erstellt
    // daher können wir im finally-Part auch das Objekt wieder freigeben.
    // Falls man nun wirklich die Sache in einem Thread ausführt, darf
    // das Objekt erst freigegeben werden, wenn der Thread beendet ist - also nicht
    // hier.
    t.Free;
  end;
end;

[sx2008]

@littleDave: Interessanter Code; aber ich würde das nicht verwenden.
Es gibt wohl niemand hier der den Sourcecode (incl. Assembler) wirklich bis in die Tiefe versteht.
Man sollte nicht möglichst clever einen Thread starten, sondern der Code sollte möglichst einfach und leicht verständlich sein. ==> TThread-Klasse verwenden!
Hier noch ein Artikel (englisch), der zeigt, dass man nicht clever, sondern einfach programmieren sollte.

[youuu]

Ich hab emir mal hierangeschaut.

Als Test, habe ich ein Beispiel von der Homepage genommen

Delphi-Quellcode:

procedure TForm1.MainProc;
 
  procedure DoSomething;
 
    procedure UpdateProgressBar(Percentage: Integer);
    begin
      ProgressBar.Position := Percentage;
      Sleep(20); // This delay does not affect the time for the 0..100 loop
                 // because UpdateProgressBar is non-blocking.
    end;
 
    procedure Finished;
    begin
      ShowMessage('Finished');
    end;
 
  var
    I: Integer;
  begin
    for I := 0 to 100 do
    begin
      // Do some time consuming stuff
      Sleep(30);
      LocalAsyncVclCall(@UpdateProgressBar, I); // non-blocking
    end;
    LocalVclCall(@Finished); // blocking
  end;
 
var
  a: IAsyncCall;
begin
  a := LocalAsyncCall(@DoSomething);
  a.ForceDifferentThread; // Do not execute in the main thread because this will
                          // change LocalAyncVclCall into a blocking LocalVclCall
  // do something
  //a.Sync; The Compiler will call this for us in the Interface._Release method
end;

Zwar durch läuft alles korrekt, aber dennoch ist das Formular geblockt, was es ja normaleweise nicht sein sollte.