Ich experementiere im Moment etwas mit threas herum, Allerdings als ich für das Forum ein zweites ohne jvl erstellen wollte. Lief mein 2.Beispielprogramm konstant langsamer als das erste deswegen, werde ich hier erst mal zwei codes ohne Threads posten


Aus dem ersten Programm, Code läuft execellent schnell!!!

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var x,i:Integer;
begin
  Label1.Caption:='Hallo';
  Form1.JvXPProgressBar1.Max:=1000000;
  x:=1;
  for i:=0 to 1000000 do
  begin
    Form1.JvXPProgressBar1.Position:=i;
    x:=x*3+1;
    x:=x div 2+1;
  end;
  Label1.Caption:='Fertig';
    Label2.Caption:='Hallo';
  Form1.JvXPProgressBar2.Max:=1000000;
  x:=1;
  for i:=0 to 1000000 do
  begin
    Form1.JvXPProgressBar2.Position:=i;
    x:=x*3+1;
    x:=x div 2+1;
  end;
  Label2.Caption:='Fertig';
end;

Keine Ahnung wieso, doch hier läuft der code extrem langsam

zusammenfalten · markieren

Delphi-Quellcode:

procedure TThreadSortForm.Button1Click(Sender: TObject);
var x,i:Integer;
begin
  ProgressBar1.Max:=1000000;
  x:=1;
  for i:=0 to 1000000 do
  begin
    ProgressBar1.Position:=i;
    x:=x*3+1;
    x:=x div 2+1;
  end;
  ProgressBar2.Max:=1000000;
  x:=1;
  for i:=0 to 1000000 do
  begin
    ProgressBar2.Position:=i;
    x:=x*3+1;
    x:=x div 2+1;
  end;
end;

Also soviel zum vorab Problem.
Mein Ziel war es, diesen Code in 2 Threads zu bringen und ihn da ablaufen zu lassen.Mein Problem dabei ist, das in beiden Beispielprogrammen die Threads meiner meinung nach extrem langsam ablaufen, speziel im vergleich zum ersten Bsp. wo der code ohne Threads wohl 100mal schneller ist.

Ich poste hier mal den kompletten Code von meinem 1.Bsp Programm.

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, JvComponentBase, JvMTComponents, StdCtrls, JvProgressBar,
  JvXPProgressBar;

type
  TForm1 = class(TForm)
    Button1: TButton;
    JvMTManager1: TJvMTManager;
    JvMTThread1: TJvMTThread;
    Label1: TLabel;
    JvXPProgressBar1: TJvXPProgressBar;
    JvXPProgressBar2: TJvXPProgressBar;
    Button2: TButton;
    JvMTThread2: TJvMTThread;
    Label2: TLabel;
    procedure JvMTThread1Execute(Sender: TJvMTThread;
      MTThread: TJvMTSingleThread);
    procedure Button2Click(Sender: TObject);
    procedure JvMTThread2Execute(Sender: TJvMTThread;
      MTThread: TJvMTSingleThread);
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
 Form1.JvMTManager1.WaitThreads;
 Form1.JvMTThread1.RunCopy;
 Form1.JvMTThread2.RunCopy;

end;

procedure TForm1.JvMTThread2Execute(Sender: TJvMTThread;
  MTThread: TJvMTSingleThread);
var x,i:Integer;
begin
  Label2.Caption:='Hallo';
  Form1.JvXPProgressBar2.Max:=1000000;
  x:=1;
  for i:=0 to 1000000 do
  begin
    Form1.JvXPProgressBar2.Position:=i;
    x:=x*3+1;
    x:=x div 2+1;
  end;
  Label2.Caption:='Fertig';
end;

procedure TForm1.Button2Click(Sender: TObject);
var x,i:Integer;
begin
  Label1.Caption:='Hallo';
  Form1.JvXPProgressBar1.Max:=1000000;
  x:=1;
  for i:=0 to 1000000 do
  begin
    Form1.JvXPProgressBar1.Position:=i;
    x:=x*3+1;
    x:=x div 2+1;
  end;
  Label1.Caption:='Fertig';
    Label2.Caption:='Hallo';
  Form1.JvXPProgressBar2.Max:=1000000;
  x:=1;
  for i:=0 to 1000000 do
  begin
    Form1.JvXPProgressBar2.Position:=i;
    x:=x*3+1;
    x:=x div 2+1;
  end;
  Label2.Caption:='Fertig';
end;

procedure TForm1.JvMTThread1Execute(Sender: TJvMTThread;
  MTThread: TJvMTSingleThread);
var x,i:Integer;
begin
  Label1.Caption:='Hallo';
  Form1.JvXPProgressBar1.Max:=1000000;
  x:=1;
  for i:=0 to 1000000 do
  begin
    Form1.JvXPProgressBar1.Position:=i;
    x:=x*3+1;
    x:=x div 2+1;
  end;
  Label1.Caption:='Fertig';

end;

end.

Hallo,

zuerst ist mir aufgefallen dass du (allem Anschein nach) in den threadlosen Beispielen einmal eine JvProgressbar und einmal eine normale verwendest, wodurch wohl der Geschwwindigkeitsunterschied zu stande kommt. Desweiteren schaue dir mal die Methode "Synchronize" von TThread an und zu guter letzt update nicht bei jedem "was auch immer du später da tun willst"-Durchgang die Progressbar, sondern nur bei grösseren Schritten - spart Performance.

Ich denke der "normale" Progressbar sorgt sofort für eine Aktualisierung der GUI und die Jedi-Progressbar meldet über Invalidate nur eine nötige Atualisierung an.

Ansonsten Achtung bei Threads: GUI-Aktualisierung müssen (bremsend) mittels Synchronsised erfolgen. Evtl. ist es besser hier asynchron diese mittels Windows-Messages + PostMessages zu erledigen.

Hi,
ich hab mir jetzt mal nicht näher die angehängten Programme noch das Threading der JEDIs angeschaut. Aber was für Erwartungen hast du denn an den Code? Was genau soll denn Threading deiner Meinung nach machen?
Versteh das hier bitte nicht falsch, es sind ernst gemeinte Fragen. Du sagst nicht viel darüber, wieviel Verständnis du in den Grundlagen schon hast. Es ist einfach wichtig zu verstehen, dass ein weiterer Thread nicht mit mehr Perfomance gleich zu setzen ist. Immerhin müssen die Threads auch verwaltet werden (was natürlich eine Menge overhead mit sich bringt). Dann gibt es auch noch konkurrierende Zugriffe auf Variablen (hier lautet das Stichwort Synchronisation) was noch einmal sehr sehr sehr viel Zeit in Anspruch nimmt.
Insbesondere hier kann sich schon die Spreu vom Weizen trennen. Es ist nicht trivial gute Synchronisation zu betreiben. Übersiehst du eine Stelle, lässt sich der Fehler später kaum finden (es ist viel schwerer als bei einem sequentiellen Ablauf). Hier kann es 10.000.000 mal gut gehen und beim nächsten Mal kommt es zu einem anderen Ablauf (der ebend nie vollständig vorhersehbar ist) und der Fehler hat Konsequenzen.
Wird hingegen zuviel Synchronisation betrieben, so kommt es leicht zu dem Problem, dass du hier hast, die Perfomance geht gegen 0. Insbesondere wenn du eine automatische Threadgenerierung verwendest, spricht einiges dafür, dass sie nicht optimal synchronisieren kann.
Für Synchronisation gilt immer :
"So spät wie möglich sperren, so früh wie möglich entsperren"
Wie gesagt ist nicht trivial.

Wichtig ist auch, was für ein Rechner deine Threads bearbeitet. Wenn du nur einen Kern hast, dann kann Threading die keinen Gewinn bringen. Hier kommt es dazu, dass du zwar mehr Verwaltung hast, aber es kann ja keine Last verteilt werden. Hast du mehr als einen Kern (auch auf mehreren CPUs), so kannst du mit deinem Programm auch nur zwei Kerne beschäftigen, selbst hier wäre kein großer Gewinn zu erwarten. Threads sollten immer dort zum Einsatz kommen, wo du wirklich leicht skalieren kannst und/oder es musst. Wenn du zum Beispiel das Zeichnen (was sehr lange dauert, aber auch mit niedrigerer Priorität laufen kann) vom Rechnen trennen möchtest, so kannst du hier Zeit gewinnen.
Baust du einen Server, so kommen sicherlich eine Menge Anfragen, hier kannst du auch jede einzelne von einem Thread bearbeiten lassen. Die Hauptvorteile sollten hier klar sein. Hast du eine Datei, die nicht im Cache liegt, so muss diese von z.B. der Festplatte geholt werden. Müsste an einem Server jeder auf die Ausführung aller Vorgängeranfragen warten, so müsste hier jeder (egal ob für diese Person die Datei benötigt wird) auf das Holen von der Platte warten. Dein CPU arbeitet im Nanosekundenbereich, deine Festplatte im ms Bereich. Das ist ein Unterschied von 10^6, in der Wartezeit kannst du locker eine ganze Menge anderer Dinge (mit der CPU) tun. Würde diese nur warten, würde sie wahrscheinlich ein gutes Weilchen schlafen.

Was Threads angeht, solltest du dir wirklich gut die Theorien dahinter anschauen. Ich glaube Luckie hat auch mal ein Tutorial zu Threads und Delphi geschrieben, such einfach mal danach.
Jedenfalls kommt man ohne die Grundlagen nicht all zu weit. Insbesondere ist es auch nicht so, dass du immer den gleichen Algorithmus für die sequentielle und die nicht-sequentielle Ausführung nehmen solltest. Schon hier können immense Unterschiede in der Perfomance auftreten.

Gruß Der Unwissende

Erst mal Dankeschön, für die ausführlichen antworten.


Dieses zwei Programme hab ich mir erstellt, um selber klar zu machen wie die sache funktionniert.Das Ziel das ich dabei verfolge,ist eine Rechenintensive Procedure in 2 Threads zu spalten,um bei einem 2 Kern Prozessor einen Performance-Gewinn zu erzielen.

Die Anzeige des fortschritts soll über eine Art Progressbar erfolgen,so wahr mein Gedanke.

Jo, auch erst heut mitbekommen,dass die Progressbar die Performance, radikal senkt.Damit hatte ich echt überhaupt nicht gerechnet.