Multithreading komischer Fehler

[SyntaxXx]

Hallo zusammen,
ich habe leider keine passendere Überschrift für das Thema gefunden, da ich sonst den kompletten Fehler hätte hinschreiben müssen.
Darum verzeiht mir.


Es geht darum, dass ich mich gerade mit Threads auseinander setze.
Nur verstehe ich den Ablauf nicht so ganz.
Besser gesagt, das Ergebnis.


Hier erst einmal mein kompletter Code.
Und bitte verzeicht die Namensgebung diverser Dinge.
Diente nur als Test.

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,System.Classes;

type
TIdThread = class(TThread)
  private
    tText: String;
  protected
    procedure Execute; override;
  public
    procedure SetText(text: String); virtual;
end;

var
  i: Integer;
  maxThreads: Integer;
  Thread: TIdThread;

procedure TIdThread.SetText(text: String);
begin
  tText := text;
end;

procedure TIdThread.Execute;
begin
  Writeln(tText);
end;

begin
  try
    Write('Wie viele Threads sollen erzeugt weden: ');
    Readln(maxThreads);

    for i := 1 to maxThreads do
    begin
      Thread := TIdThread.Create();
      Thread.FreeOnTerminate := true;
      Thread.SetText('Ich bin Thread ' + IntToStr(i));
      Thread.Execute;
    end;
    Readln;
    { TODO -oUser -cConsole Main : Code hier einfügen }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Wenn ich dieses Gebilde nun ausführe und die Zahl 1 eingebe, dann erhalte ich komischerweise folgendes als Ergebnis:
Ich bin Thread 1
Ich bin Thread 1
Ich bin Thread 1

Die Ausgabe erscheint also 3 mal.
Nur die Frage ist, wieso ???


Desweiteren fürde ich interessieren, warum ich der Execute-Prozedur keine Parameter mitgeben kann?
Ich musste ich es über einen Setter machen.


Vielen Dank schonmal.

[jaenicke]

Du rufst Execute direkt auf. Das ist schon einmal falsch.

[Sir Rufo]

Versuch es mal so

Delphi-Quellcode:

    for i := 1 to maxThreads do
    begin
      Thread := TIdThread.Create( true ); // Thread im angehaltenen Zustand erzeugen
      Thread.FreeOnTerminate := true;
      Thread.SetText('Ich bin Thread ' + IntToStr(i));
      Thread.Start;
    end;

Obwohl es keine gute Idee ist aus einem Thread heraus auf die Console zuzugreifen.
Und in diesem Fall, sollte auch auf die Beendigung des Threads gewartet werden.

[SyntaxXx]

Ok, es ist mit den Änderungen schonmal ein wenig besser.
Allerdings kommen Zahlen immernoch doppelt vor.

Wie würde das denn aussehen, wenn ich auf Beendigung der Threads warten würde?
Und was müsste ich machen, wenns wirklich richtig sein sollte?

Gebe mich ungern mit halbrichtgen Lösungen zufrieden ^^
Also damit meine ich nicht eure Lösungsvorschläge, die haben ja meine Frage beantwortet. Und dafür danke ich euch.

Nur wie gehts richtig

[hathor]

Beispiel:
von hier: http://www.delphipraxis.net/829503-post7.html

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure ThreadTerminated(Sender: TObject);

  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

type
  TMyThread = class(TThread)
  protected
    Counter : integer; // nur für die Ausgabe
    procedure Execute; override;
  end;

procedure TMyThread.Execute;
begin
  // Der Thread soll einfach nur warten. Dabei wartet er
  // zufällig zwischen 1 und 11 Sekunden
  Sleep(1000 + random(10001));
end;

procedure TForm1.ThreadTerminated(Sender: TObject);
begin
  if Sender is TMyThread then
  begin
    Memo1.Lines.Add('Der Thread '+IntToStr(TMyThread(Sender).Counter)+' ist fertig');
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var i: integer;
begin
  for i:=1 to 6 do
  begin
    Memo1.Lines.Add('Erstelle Thread Nummer '+IntToStr(i));
    with TMyThread.Create(True) do
    begin
      Counter := i;
      FreeOnTerminate := True;
      OnTerminate := ThreadTerminated;
      Resume;
    end;
  end;
end;

end.

[himitsu]

Im Prinzip müsstest du das WriteLn im Thread auch per Synchronize absichern.