Zugreif auf ein Array von mehreren Threads

[Pussyranger]

Hallo,

ich arbeite zum ersten Mal mit Threads und bräuchte deshalb eure Hilfe.
Ich habe eine Threadklasse erstellt, die Berechnungen durchführt und diese dann in einem Array speichert.
Durch diese ButtonClick-Prozedur werden mehrere dieser Threads erstellt:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
VAR i: integer;
begin
  for i := 1 to Threads do
  begin
    Thread[i]:=TMeinThread.Create({...});
    Thread[i].OnTerminate:=ThreadDone;
    Thread[i].FreeOnTerminate:=true;
    Thread[i].Resume;
  end;
end;

Die Threadklasse sieht grob so aus:

Delphi-Quellcode:

procedure TMeinThread.Execute;
VAR xxz,yyz: integer;
begin
  //imgwtrd und imghtrd sind in der Größenordnung 500-2000
  for xxz:=0 to imgwtrd do
  begin
    for yyz:=0 to imghtrd do
    begin
      {Berechnungen durchführen}
      Synchronize(Pixel_zeichnen);
    end;
  end;
end;

procedure TMeinThread.Pixel_zeichnen;
begin
  MeinArray[ThreadNotrd,xx,yy]:={Farbe, die auf der Verarbeitung der Berechnung aus Exexute basiert};
  //ThreadNotrd wird im Konstruktor übergeben und ist für jeden gestarteten Thread individuell.
  //MeinArray ist ein global deklariertes Array der MainForm
end;

Obwohl die Prozedur Pixel_zeichnen geschützt mit Synchronize aufgerufen wird, scheinen die Threads wie wild durcheinander auf das Array zuzugreifen.
Was mache ich also falsch?
LG,

Pussyranger

[himitsu]

Auf das Array sollte scheinbar ordentlich funktionieren, solange es nicht nicht noch anderen Code gibt, welcher auch darauf zugreift.

Den einzigen Nachteil, welchen ich hier sehe:
du synchronisierst sooooooo oft, daß sich die Threads gegenseitig ausbremsen/blockieren würden, und dazu wird auch noch der Hauptthread lahmgelegt, da er selber ja kaum noch Zeit für sich bekommt ... selbst wenn nur ein thread läuft, solange soeine Schleife am Arbeiten ist.

[FredlFesl]

Zitat:

Zitat von Pussyranger (Beitrag 1126367)

Obwohl die Prozedur Pixel_zeichnen geschützt mit Synchronize aufgerufen wird, scheinen die Threads wie wild durcheinander auf das Array zuzugreifen.
Was mache ich also falsch?

Was erwartest Du denn?
Du sorgst ja nicht dafür, das die Threads nicht 'wild durcheinander auf das Array' zugreifen.

Wenn Du garantierst, das jeder Thread wirklich einen exklusiven Bereich des Bitmaps erzeugt, dann musst Du den Schreibzugriff nicht synchronisieren. Natürlich kannst Du dann keine Bitmap nehmen, sondern solltest ein Array verwenden und dann -als Effekt- ab und an (alle 100-200ms oder seltener) das Array in ein Bitmap auf dem Bildschirm kopieren.

TBitmaps sind nicht threadsicher, oder?:gruebel:

[Pussyranger]

Danke für die Antworten!

@himitsu: Am Synchronize-Aufruf lag es tatsächlich nicht, sondern daran, dass ich beim Konstruktoraufruf ein i mit einer 1 vertauscht hatte :oops:
Danke auch für den Hinweis, dass ich zu oft synchronisiere. Hatte mich schon gewundert, warum im Testlauf Multithreading scheinbar langsamer war als ein einziger Thread :-D

Jetzt läuft alles prima :)