Kontinuierlich Schleife

[raena]

Hallo zusammen,

wie kann ich eine kontinierlich laufende Schleife programmieren,
die nicht nur dann läuft wenn irgendein Ereignis eintritt sondern immer?

Wie kann man mehrere Schleifen permanent parallel mit unterschiedlicher Schnelligkeit
laufen lassen?

Vielen Dank schonmal Raena.

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
showmessage('test');
end;



end.

[sirius]

mit Threads

Delphi-Quellcode:

unit Unit1;

interface

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

type TSchleife=class(TThread)
       constructor create(Memo:TMemo;speed:integer;index:integer); reintroduce;
      protected
       procedure execute; override;
      private
       FMemo:TMemo;
       FSpeed:integer;
       FIndex:integer;
       FsyncText:string;
       procedure syncVCL;
end;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Memo1: TMemo;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  private
    { Private-Deklarationen }
    Schleifen:array of TSchleife;
    procedure StopSchleifen;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

constructor TSchleife.create(Memo:TMemo;speed:integer;index:integer);
begin
  freeonterminate:=true;
  FMemo:=memo;
  Fspeed:=speed;
  FIndex:=index;
  inherited create(false);
end;
procedure TSchleife.execute;
var wait:integer;
begin
  while not terminated do  //die Schleife
  begin
    
    //Ausgabe eines Textes über synchronize
    FsyncText:='Thread '+inttostr(FIndex)+':  Speed '+inttostr(FSpeed);
    synchronize(syncVCL);
    
    //Verzögerung
    wait:=FSpeed;
    while (not terminated)and(wait>0) do
    begin
      sleep(10);
      dec(wait);
    end;
  end;
end;
procedure TSchleife.syncVCL;
begin
  Fmemo.Lines.Add(FSyncText);
end;



procedure TForm1.Button1Click(Sender: TObject);
var pos:integer;
begin
  //starten einer neuen Schleife
  pos:=length(Schleifen);
  setlength(schleifen,pos+1);
  Schleifen[pos]:=TSchleife.create(Memo1,random(100)+10,pos+1);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  //Alle Schleifen beenden
  StopSchleifen;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  randseed:=5000;
end;

procedure TForm1.StopSchleifen;
var i:integer;
begin
  for i:=0 to high(Schleifen) do Schleifen[i].Terminate;
  finalize(Schleifen);
end;

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  stopSchleifen;
end;

end.

[mkinzler]

Sleep() ist halt nur ein Rechenzeitkiller.

[sirius]

Zitat von mkinzler:

Sleep() ist halt nur ein Rechenzeitkiller.

1. Es befindet sich in einem Thread
2. Wollte ich damit nur die vom OP gefoerderten unterschiedlichen Laufzeiten der Schleifen simulieren.

[mkinzler]

Zitat:

1. Es befindet sich in einem Thread

ist doch egal. Aktives warten ist immer schlecht. Besser Delay

[sirius]

Wozu denn Delay, wenn in diesem Thread eh keine Messages verarbeitet werden.

Sleep ist nicht der Teufel, der generell erst einmal gebrandmarkt werden muss

Edit: Ausserdem wird in diesen Delay-Varianten die globale Variable Application verwendet. Das kann tödlich enden. Aber wie gesagt, ohne Messagehandling keine Messageverarbeitung. Oder andersrum

Edit2: Und über Optimierungen in jeder Hinsicht, reden wir, wenn das Problem näher bekannt ist. Vielleicht ist schon ein Thread zu viel und es würden einfache Timer ausreichen. Vielleicht müssen wir aber auch in die Threads Timer legen, oder wir brauchen im Thread keine Zeitverzögerung mehr,....

[dominikkv]

Sleep sagt nur das in den angegebenen Milisekunden der Thread keine Rechenzeit mehr zugeteilt bekommt.
Somit schläft der Thread also, und die Rechenzeit die dadurch frei wird wird auf die anderen Threads vereilt.

[mashutu]

@raena:
Hallo, was willst Du denn uebrhaupt machen. Wenn man das wuesste, waere es sicherlich einfacher das geeignete Mittel zu finden.
eine kontinuierliche Schleife macht eigentlich keinen Sinn. (Bin aber gerne bereit dazuzulernen)

[mkinzler]

Sleep ist eine Kernelfunktion von Windows.

[RavenIV]

Zitat von mashutu:

@raena:
Hallo, was willst Du denn uebrhaupt machen. Wenn man das wuesste, waere es sicherlich einfacher das geeignete Mittel zu finden.
eine kontinuierliche Schleife macht eigentlich keinen Sinn. (Bin aber gerne bereit dazuzulernen)

Das kann schon Sinn machen.
z.B. in einem Thread, der auf Signale an einer seriellen Schnittstelle wartet.
- warten auf Signal <--------
- Signal verarbeiten ¦
- dem Hauptthread mitteilen -
Das ist eine kontinuierliche Schleife.

Oder was meinst Du, was die Nachrichtenverarbeitung von Windows ist?