BeginThread - Methoden aufruf

[Björn Ole]

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

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 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 von youuu:

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: 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 . 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.