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

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:

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

[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 :angel2:

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

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:

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?

[mashutu]

Zitat:

Zitat von RavenIV

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?

Schon klar, was die Nachrichtenverarbeitung von Windows ist.
Aber ich habe auch schon Kommunikation mit seriellen Geraeten ohne Endlosscheifen programmiert ...
Daher isses IMHO erforderlich zu wissen, auf was der OP rauswill.

[raena]

Hallo zusammen,

vielen Dank für die schnellen Antworten.
Der Code funktiniert soweit ich das beurteilen kann,
ich habe als Anfaenger nur probleme die Sache mit den Threats
zu verstehen.
Gibt es für den Anfang nicht eine einfachere Lösung?
Das Ziel wäre zB in einem Form mit Buttons und Memos etc.
eine eine ablaufende Zeit in Sekunden anzuzeigen, die
"permanent" geupdated wird, ohne dass ein Ereignis eintritt?
Parallel sollte das Programm aber auf Ereignisse reagieren.
Vielleicht sollte ich mit einer einfachen Loesung
anfangen und später die Sache mit den Threats angehen.

:oops:

Merci, Raena.

[Oxmyx]

Das ist mal wieder der klassische Fall, wo einem Anfänger eine völlig unpassende Lösung angeboten wird für ein Problem, das er überhaupt nicht hat. Wenn's darum geht einen Countdown auf ein Formular zu setzen, dann würde ich einem Anfänger ein Timer empfehlen. Einfach aufs Formular ziehen, doppelt draufklicken, Countdown reinschreiben, fertig.

[sirius]

Zitat:

Zitat von Oxmyx

Das ist mal wieder der klassische Fall, wo einem Anfänger eine völlig unpassende Lösung angeboten wird für ein Problem, das er überhaupt nicht hat. Wenn's darum geht einen Countdown auf ein Formular zu setzen, dann würde ich einem Anfänger ein Timer empfehlen. Einfach aufs Formular ziehen, doppelt draufklicken, Countdown reinschreiben, fertig.

Aus dem hier war allerdingas nicht zu erkennen, dass ein einfacher Timer reichte:

Zitat:

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

Aber nach der verbesserten Aufagenstellung ist ein Timer völlig ausreichend.

[raena]

Ja das sehe ich auch so. Die Sache mit den Threats ist bestimmt gut.
Nun aber da ich die Aufgabe klarer formuliert habe wird bestimmt einfacher.

So, mit einem Timer habe ich folgendes Problem:
das Label wird zwar schoen geupdated, der Button ist aber nicht mehr ansprechbar.

Wie kann man erreichen, dass der Button noch reagiert, die Zeit aber trotzdem läuft?

Danke.

Delphi-Quellcode:

unit Unit2;

interface

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

type
  TForm2 = class(TForm)
    Button1: TButton;
    Timer1: TTimer;
    Label1: TLabel;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form2: TForm2;

implementation

{$R *.dfm}

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

procedure TForm2.FormCreate(Sender: TObject);
begin
timer1.Enabled:=true;
end;

procedure TForm2.Timer1Timer(Sender: TObject);
var i:integer;
begin
i:=0;
repeat
label1.Caption:=inttostr(i)+'               ';
label1.Refresh;
inc(i);
sleep(1000);
until (i>100);

end;

end.

[Klaus01]

Delphi-Quellcode:

procedure TForm2.Timer1Timer(Sender: TObject);
//var i:integer;
begin
//i:=0;
//repeat
label1.Caption:=inttostr(i)+'               ';
label1.Refresh;
//inc(i);
//sleep(1000);
//until (i>100);

Lass das sleep und die Schleife mal aus dem Code raus und stelle das Interval so ein wie Du es brauchst.
Grüße
Klaus

[sirius]

Was du brauchst ist eben keine Schleife sondern eine Funktion, die in regelmäßigen Zeitintervallen aufgerufen wird. Das macht alles Windows (und ich bisschen Delphi) für dich. du musst in die Methode nur reinschreiben, was nach dem Interval (siehe im Objectinspector) eben regelmäßig gemacht werden soll