Hallo, ich bins mal wieder!

Ich erstelle unterschiedlich viele Threads, auf deren Beendigung das Programm warten soll. Bisher hab ich immer über das OnTerminate-Ereignis der Threads die Anzahl der Threads runtergezählt und mit

markieren

Delphi-Quellcode:

while ThreadAnzahl > 0 do
begin
  Sleep(1);
  Application.ProcessMessages;
end;

auf die Threads gewartet. Nun ist das natürlich höchst unschön und ich denke, dass es mit WaitForMultipleObjects effizienter wäre.
Leider kapiert WaitForMultipleObjects aber nie, dass die Threads beendet wurden

Hier die Prozedur, in der die Threads erzeugt werden:

zusammenfalten · markieren

Delphi-Quellcode:

function Unterschiede_markieren(Bild1, Bild2: TBitmap; Blend: Real; Toleranz: Byte):TBitmap;
VAR i,j,Breite,Hoehe,Itert:integer; B1,B2: ColorArray; SysInfo: TSystemInfo; HandleArray: array of THandle;
begin
  GetSystemInfo(SysInfo);
  ThreadCount:=SysInfo.dwNumberOfProcessors;
  SetLength(Thread, ThreadCount);
  SetLength(HandleArray, Threadcount);

  result:=TBitmap.Create;
  if NOT Assigned(fertig_Bild) then fertig_Bild:=TBitmap.Create;
  fertig_Bild.Width:=Bild2.Width;
  fertig_Bild.Height:=Bild2.Height;

  for i := 0 to ThreadCount-1 do
  begin
    Thread[i]:=TDifference_Finder.Create(Bild1, Bild2, Round(i*Bild2.Height/ThreadCount), Round((i+1)*(Bild2.Height-1)/ThreadCount), Blend, Toleranz, true);
    HandleArray[i]:=Thread[i].Handle;
    Thread[i].FreeOnTerminate:=true;
    Thread[i].Resume;
  end;

  WaitForMultipleObjects(Length(HandleArray), @HandleArray[0] ,true, INFINITE);

  result.Assign(fertig_Bild);
end;

LG,

Pussyranger

EDIT: Rufst du in den Threads synchronize oder ähnliches auf? Das könnte einen netten Deadlock geben.

[EDIT]Vermutlich Blödsinn: [/EDIT]
Könnte es sein, dass ein Thread schon fertig ist, wenn WaitForMultipleObjects aufgerufen wird?
Wie sich WaitForMultipleObjects dann verhält, habe ich nicht gefunden. Rufe mal am Ende des Threads ein sleep(1000); (bzw. einen Zeitraum, indem das Warten auf jeden Fall ausgelöst wird) auf und gucke, ob das dass Problem behebt.

Irgendwie ja schon komisch ... da wird die Berechnung in den Hintergrund geschickt und im Vordergrund wird der Thread schlafen gelegt ... irgendwie hatte ich das mit den Threads anders in Erinnerung ...

Ab in den Hintergrund und wenn alle fertig sind - Reaktion auf das OnTerminate-Event - dann die Ergebnisse zusammentragen und ausgeben.

Moin moin,

hast du geprüft, ob wirklich alle Threads beendet sind?

Eventuell gibt es aber auch eine Zugriffsverletzung in den Threads, da ja die Threads auf die gleichen Objekte zugreifen (Bild1, Bild2) ... und sogar noch auf fertig_bild!

TBitmap ist nicht threadsicher ... das hatten wir doch schon

Sleep(1000); bewirkt nichts.
Da alle Threads zumindest das OnTerminate-Ereignis auslösen, nehme ich an, dass die Threads dann auch beendet werden.
Eine Zugriffsverletzung gibt es denke ich nicht, denn bisher hat ja alles wunderbar funktioniert. Die Threads werden synchronisiert, bevor auf fertig_Bild zugegriffen wird.

Zitat von Pussyranger:

Die Threads werden synchronisiert, bevor auf fertig_Bild zugegriffen wird.

So wie ich synchronize verstanden habe, wartet es, bis der Main-Thread wieder im Messageloop ist, um dann sicher die übergebene Prozedur ausführen zu können.
Dein Main-Tread wartet allerdings auf deine Arbeitsthreads.
Klassischer Deadlock.

Am Synchronize hats gelegen! Allerdings muss ich ja irgendwie die Teilbilder zusammenfügen.
Übers OnTerminate-Ereignis geht es nicht, da das auch zu einem DeadLock führen würde.
Nun habe ich die Deklaration für die Teilbilder in den public-Bereich geschrieben.
Wenn WaitForMultipleObjects beendet ist, rufe ich folgenden Code auf:

markieren

Delphi-Quellcode:

for i := 0 to ThreadCount-1 do
begin
  fertig_Bild.Canvas.Draw(0, Thread[i].StartYt, Thread[i].Finish);
  Thread[i].Finish.Free;
end;

Trotzdem wird der Speicher von Finish nicht wieder freigeben. Wieso?

Edit: FreeOnTerminate hab ich auf false gesetzt.

Zitat von Pussyranger:

Trotzdem wird der Speicher von Finish nicht wieder freigeben. Wieso?

Woran erkennst du denn, das der Speicher nicht freigegeben wird?
Die Zahl im Taskmanager muss auf solche Änderung nicht reagieren.

Ich wollte die Prozedur 100 Mal hintereinander aufrufen. Dabei hat mir der Taskmanager für das Programm zwar immer maximal 800MB angezeigt, aber die Auslastung des RAM insgesamt ist kontinuierlich bis auf 100% gestiegen.