mehrere funktionsparameter bei beginthread übergeben?

[griever]

hi,
ich wollte mal fragen wie man mehrere Parameter einer funktion bei aufruf von Beginthread übergibt
kleines beispiel:
-funktion:

Delphi-Quellcode:

funktion rechne(a,b:integer):integer;
begin
result := a+b;
end;

-aufruf:

Delphi-Quellcode:

a1s := 2;
b1s := 3;
threadhandle:=beginThread(nil,0,TFNThreadStartRoutine(@rechnen),@a1s, 0, threadid);

nun versuch ich schon seit einiger zeit herauszufinden wie man aus 2 parametern einen macht aber was nützliches hab ich noch nicht gefunden.
wie kann ich nun auch b1s mit übergeben?

[Luckie]

Erstell ein Record mit den Parametern und übergib den Record an die Funktion.

[griever]

und wie muss das record aussehen?

Delphi-Quellcode:

  myrecord = record
    a: Pinteger;
    b: Pinteger;

so oder muss ich dann die integer weitergeben?

[Luckie]

Ganz normal. Du übergibst dann den Zeiger auf den Record. Siehe auch mein Threading Tutorial: http://delphitutorials.michael-puff.de

Parameter auf dem Heap ablegen:

Delphi-Quellcode:

(******************************************************************************
 *                                                                            *
 *  Project: Thread Programmierung unter Windows mit Delphi                   *
 *           Paramter-Demo                                                    *
 *                                                                            *
 *  Copyright (c) Michael Puff  [url]http://www.michael-puff.de[/url]                    *
 *                                                                            *
 ******************************************************************************)

program ParameterHeap;

{$APPTYPE CONSOLE}

uses
  Windows;

type
  TThreadParams = packed record
    Number: Integer;
    Text: string;
  end;
  PThreadParams = ^TThreadParams;

function IntToStr(Int: integer): string;
begin
  Str(Int, result);
end;

function ThreadFunc(tp: PThreadParams): Integer;
var
  Number            : Integer;
  Text              : string;
  s                 : string;
begin
  // Parameter lokalen Variablen zuweisen.
  Number := PThreadParams(tp)^.Number;
  Text := PThreadParams(tp)^.Text;
  s := 'Zahl: ' + IntToStr(Number) + #13#10 + 'Text: ' + Text;
  // ExitCode enthält Rückgabewert der Messagebox.
  Result := MessageBox(0, PChar(s), 'Thread', MB_YESNO or MB_ICONINFORMATION);
  // Reservierten Speicher für Parameter wieder freigeben.
  Dispose(tp);
end;

procedure RunThread;
var
  tp                : PThreadParams;
  Thread            : THandle;
  ThreadID          : Cardinal;
  ExitCode          : Cardinal;
begin
  // Speicher für Struktur reservieren.
  New(tp);
  // Daten den feldern der Struktur zuweisen.
  tp.Number := 42;
  tp.Text := 'Die Antwort.';
  // Thread erzeugen.
  Thread := BeginThread(nil, 0, @ThreadFunc, tp, 0, ThreadID);
  // Auf Beendigung des Threads warten.
  WaitForSingleObject(Thread, INFINITE);
  // Rückgabewert ermitteln...
  GetExitCodeThread(Thread, ExitCode);
  // ...und auswerten.
  case ExitCode of
    IDYES: Writeln('Benutzer hat "Ja" angeklickt.');
    IDNO: Writeln('Benutzer hat "Nein" angeklickt.');
  end;
  // Thread-Handle schliessen udn somit das Thread-Objekt zerstören.
  CloseHandle(Thread);
end;

begin
  RunThread;
  Readln;
end.

Parameter auf dem Stack ablegen:

Delphi-Quellcode:

(******************************************************************************
 *                                                                            *
 *  Project: Thread Programmierung unter Windows mit Delphi                   *
 *           Paramter-Demo                                                    *
 *                                                                            *
 *  Copyright (c) Michael Puff  [url]http://www.michael-puff.de[/url]                    *
 *                                                                            *
 ******************************************************************************)

program ParameterStack;

{$APPTYPE CONSOLE}

uses
  Windows;

type
  TThreadParams = packed record
    Number: Integer;
    Text: string;
  end;
  PThreadParams = ^TThreadParams;

function IntToStr(Int: integer): string;
begin
  Str(Int, result);
end;

function ThreadFunc(tp: PThreadParams): Integer;
var
  Number            : Integer;
  Text              : string;
  s                 : string;
begin
  Number := PThreadParams(tp)^.Number;
  Text := PThreadParams(tp)^.Text;
  s := 'Zahl: ' + IntToStr(Number) + #13#10 + 'Text: ' + Text;
  Result := MessageBox(0, PChar(s), 'Thread', MB_YESNO or MB_ICONINFORMATION);
end;

procedure RunThread;
var
  tp                : TThreadParams;
  Thread            : THandle;
  ThreadID          : Cardinal;
  ExitCode          : Cardinal;
begin
  tp.Number := 42;
  tp.Text := 'Die Antwort.';
  Thread := BeginThread(nil, 0, @ThreadFunc, @tp, 0, ThreadID);
  WaitForSingleObject(Thread, INFINITE);
  GetExitCodeThread(Thread, ExitCode);
  case ExitCode of
    IDYES: Writeln('Benutzer hat "Ja" angeklickt.');
    IDNO: Writeln('Benutzer hat "Nein" angeklickt.');
  end;
  CloseHandle(Thread);
end;

begin
  RunThread;
  Readln;
end.

[Apollonius]

Die zweite Möglichkeit funktioniert aber nur, wenn man tatsächlich in der selben Routine auf die Beendigung des Threads wartet. Das dürfte recht selten vorkommen.

[Luckie]

Logisch. Da beim Verlassen der Routine die lokalen Variablen ungültig werden. Aber es geht. :warn: :mrgreen:

[Apollonius]

Dass du das weißt, war mir klar. Das war nur als Hinweis für den unbedarften Leser gedacht.

[griever]

danke das hab ich denke ich mal verstanden
jetzt muss ichs nur noch auf meine:
"pointer auf ein array von records die aus pointern auf array von zahlen bestehen" variante umwandeln^^ und nachdem ich das gesachafft hab muss ich rausfinden warum ich zugriffsverletzungen bekomme wenn ich die zahlen verändern will.

[himitsu]

statt einem Record könnte man auch ein Objekt übergeben (also die Objektreferenz) ... wollt ich nur mal so erwähnen,
aber das mit dem Record ist wohl gängiger.

[sirius]

Zitat:

Zitat von himitsu

statt einem Record könnte man auch ein Objekt übergeben (also die Objektreferenz) ... wollt ich nur mal so erwähnen,
aber das mit dem Record ist wohl gängiger.

Und man kan die Threadfunction aucvh gleich asl Methode der zugehörigen Klasse nehmen:

Delphi-Quellcode:

type TmyThread=class
      private
       a,b:Integer;
      public
       function ThreadFunc:Integer;
       property ...
     end;

...

//und im Aufruf:
myThread:=TmyThread.create;
myThread.property:=xyz;
BeginThread(nil,0,@TmyThreadClass.ThreadFunc,myThread,0,id);

[Luckie]

Zitat:

Zitat von sirius

Und man kan die Threadfunction aucvh gleich asl Methode der zugehörigen Klasse nehmen:

Hast du das schon mal so gemacht?

[sirius]

Zitat:

Zitat von Luckie

Zitat:

Zitat von sirius

Und man kan die Threadfunction aucvh gleich asl Methode der zugehörigen Klasse nehmen:

Hast du das schon mal so gemacht?

Ja.

Delphi-Quellcode:

//Hier als Aufsatz für die Klasse TDirectory, welche (im Constrcutor) ein Verzeichnis samt Unterverzeichnisse durchforstet 
//und dafür bekanntlich ein Weilchen braucht:

type
  TSearchThread=class
      Constructor Create(aParent: TDirectory; const aName:String;
                            aFileNotify:TFileNotify=nil;
                            aOnFinished:TDirectoryNotify=nil); reintroduce;
      Destructor Destroy; override;
    private
      FName:string;
      FNotify:TFileNotify;
      FWnd:Hwnd;
      FParent:TDirectory;
      FThreadID:Cardinal;
      FonFinished:TDirectoryNotify;
      procedure WndProc(var Message:TMessage);
      procedure Notify(aFile:TFile);
      function ThreadProc:Integer;
      procedure DoNotify(aFile:TFile);
  end;

...


constructor TSearchThread.Create(aParent:TDirectory; const aName: String;
  aFileNotify: TFileNotify; aOnFinished:TDirectoryNotify);
begin
  inherited Create;
  FParent:=aParent;
  FName:=aName;
  FOnFinished:=aOnFinished;
  FNotify:=aFileNotify;
  Fwnd:=Classes.AllocateHWnd(WndProc);
  BeginThread(nil,0,@TSearchThread.ThreadProc,self,0,FThreadID);  //Here you are ;-)
end;

destructor TSearchThread.Destroy;
begin
  Classes.DeallocateHWnd(Fwnd);
  inherited;
end;

procedure TSearchThread.DoNotify(aFile: TFile);
begin
  if assigned(FNotify) then
    FNotify(aFile);
end;

procedure TSearchThread.Notify(aFile: TFile);
begin
  if assigned(FNotify) then sendmessage(Fwnd,WM_User,0,integer(aFile));
end;

function TSearchThread.ThreadProc: Integer;
var temp:TFileNotify;
begin
  if assigned(FNotify) then temp:=Notify
                       else temp:=nil;
  FParent.Create(FName,temp);
  PostMessage(Fwnd,WM_Close,0,0);
  result:=0;
end;

procedure TSearchThread.WndProc(var Message: TMessage);
begin
  case Message.msg of
    WM_User: DoNotify(TFile(Message.LParam));
    WM_Close: begin
      try
        if assigned(FOnFinished) then FOnFinished(self.FParent);
      finally
        self.Free;
      end;
    end;
    else
      DefWindowProc(Fwnd,Message.Msg,Message.WParam,Message.LParam);
  end;
end;


//Und der Start des Threads aus TDirectory:
constructor TDirectory.CreateThreaded            
            (const aName: String;           //Verzeichnispfad
             aFileNotify: TFileNotify;      //Ereignis beim Finden einer neuen Datei
             aOnFinished:TDirectoryNotify); //Ereignis, wenn die Suche beendet ist
begin
  TSearchThread.Create(self,aName,aFileNotify,aOnFinished);
end;

[Luckie]

Ich frage nur, weil in BeginThread ja ein Funktionszeiger benötigt wird und kein Methodenzeiger.

[sirius]

Es wird ein Pointer erwartet bzw. die CPU erwartet einen 32bit-Wert. Und das klappt problemlos.
Man muss halt nur als Parameter (lparam) den Objektzeiger mitgeben, denn die Methode hätte ja ganz gern genau diesen.