Handle count erhöht sich permanent

[Klaus01]

Hallo,

ich weiß nicht mehr weiter..

Ich habe einen Threadpool (poolsize = 2xcpuCount).

Delphi-Quellcode:

procedure TThreadpool.Execute;
var
  i: Byte;
begin
  while not terminated do
    begin
      try
        if (fRunningTasks.count < fPoolSize) and (fTaskList.Count > 0) then
          begin
            fRunningTasks.Insert(0,fTaskList[0]);
            fTaskList.Delete(0);
            fRunningTasks[0].Start;
          end;
      except
        on E:Exception do
          fLogger.add(1,format('%s: Error while inserting task: %s',[self.ClassName,E.Message]));
      end;

      try
        if fRunningTasks.count > 0 then
          for i:= fRunningTasks.Count -1 downto 0 do
            begin
              if fRunningTasks[i].finished then
                begin
                  fRunningTasks[i].Free;
                  fRunningTasks.Delete(i);
                end;
            end;
        sleep(50);
      except
        on E:Exception do
          fLogger.add(1,format('%s: Error while deleting tasks: %s',[self.ClassName, E.Message]));
      end;
    end;
end;

Die Tasks sind auch Threads (freeOnTerminate = false).

fRunningTasks ist eine generische TList.

Ich weiß es ist nicht optimal die laufenden Threads in einer Schleife zu überwachen..

Die Tasks werden alle 5 Minuten ausgeführt.
Es werden 173 Tasks abgearbeitet.

Nach jedem Durchlauf erhöht sich die Anzahl der Handles im Windows TaskManager um 173.
Der "Speicherverbrauch" um ca 300kByte.
Die Anzahl der Thread geht aber nachdem ein Durchlauf beendet wurde wieder auf den Normalwert (2) zurück.
Meiner Meinung nach, werden die Tasks(Threads) ordnungsgemäß beendet.

Warum erhöht sich dann noch die Anzahl der Handles?

Grüße
Klaus

[TiGü]

Zitat von Klaus01:

Meiner Meinung nach, werden die Tasks(Threads) ordnungsgemäß beendet.

Zeige mal die Definition der Task-Threads und vielleicht bisschen relevanten Code.
Anscheinend werden zwar da Handles geöffnet, aber nicht geschlossen.
Was passiert in den Tasks?

[himitsu]

Warum keine TObjectList<T> mit OwnsObjects=True? (das Freigeben "fRunningTasks[i].Free;" macht die dann selber)

Das Erstellen von Threads geschieht im selben Thread, wie dein Löschen?
Wenn nicht, warum gibt es hier dann keine Syncronisierung/Threadabsicherung?

Was macht du in deinen Threads?
Wenn die Threads intern nichts machen (leeres Execute usw.), gehen die Handle dann auch noch hoch?

[Klaus01]

Hallo TiGü,

ich hoffe der Code ist relevant genug.
Ich sehe darin nichts auffälliges..

Delphi-Quellcode:

  TThreadTask = class(TThread)
    protected
      procedure onTerminate(sender: TObject);
    private
      fDevice: TDevice;
      fTask: TTask;
      fLogger: TLogger;
    public
      constructor create(device: TDevice; task: TTask);
      destructor Destroy; override;
      procedure Execute; override;
  end;

Delphi-Quellcode:

constructor TThreadTask.create(device: TDevice; task: TTask);
begin
  inherited create(true);
  freeOnTerminate := false;        
  fLogger := TLogger.instance;
  fDevice := TDevice.create;
  fDevice.id := device.id;
  fDevice.name := device.name;
  fDevice.powerSourceId := device.powerSourceId;
  fTask := task;
  inherited onTerminate := onTerminate;
end;

Delphi-Quellcode:

destructor TThreadTask.Destroy;
begin
  freeAndNil(fDevice);
end;

und die Execute Routine

Delphi-Quellcode:

procedure TThreadTask.Execute;
begin
if assigned(fDevice) then
  begin
    case fTask of
      powerState: begin
                    try
                      fDevice.getDevicePowerState;  //snmp Abfrage
                      case fDevice.powerState of
                        true: fLogger.add(6,format('Scan finished for: <%s - %s>',[fDevice.name, 'on']));
                        false: fLogger.add(6,format('Scan finished for: <%s - %s>',[fDevice.name, 'off']));
                      end;
                    except
                      on E: Exception do
                        begin
                          fLogger.add(1,format('Error in power-state query: %s',[E.Message]));
                        end;
                    end;
                  end;
      powerOn: begin
                 try
                   fDevice.powerOn;
                 except
                   on E: Exception do
                     fLogger.add(1,format('Error in power-on operation: %s',[E.Message]));
                 end;
               end;
      powerOff: begin
                  try
                    fDevice.powerOff;
                  except
                    on E:Exception do
                      fLogger.add(1,format('Error in power-off operation: %s',[E.Message]));
                  end;
                end;
    end;
  end;
end;

[Klaus01]

Zitat von himitsu:

Das Erstellen von Threads geschieht im selben Thread, wie dein Löschen?
Wenn nicht, warum gibt es hier dann keine Syncronisierung/Threadabsicherung?

Was macht du in deinen Threads?
Wenn die Threads intern nichts machen (leeres Execute usw.), gehen die Handle dann auch noch hoch?

Der ThreadTask wird ausserhalb erstellt
und der TaskListe im Threadpool hinzugefügt.
Der ThreadTask wird suspended erstellt.

Delphi-Quellcode:

function TThreadpool.addTask(task: TThreadTask): Boolean;
begin
  fCriticalSection.Acquire;
  result := false;
  if fTaskList.Count < fMaxTaskList then
    begin
      fTaskList.Add(task);
      result := true;
    end;
  fCriticalSection.Release;
end;

Im Threadpool wird der ThreadTask dann gestartet, wenn ein Platz in fRunningTasks frei ist.

Auch wenn der Threadtask nichts ausführt, erhöht sich die Anzahl der Handles wie vorher auch.

Grüße
Klaus

[himitsu]

Zitat:

Der ThreadTask wird ausserhalb erstellt

Und wo ist dann die fCriticalSection, beim Durchlaufen und vorallem Löschen der Items?

Wie gesagt, wenn du im Constructor und Execute deinen Code mal auskommentierst, bleiben dann die Handle gleich?




Bezüglich deinem komischen OnTerminate-Konstrukt:

Delphi-Quellcode:

protected
  procedure DoTerminate; override;

procedure TThreadTask.DoTerminate;
begin
  inherited;
  ...
end;

// bzw., wenn der Code im Hauptthread ausgeführt werden soll (OnTerminate wird ja auch synchronisiert)

procedure TThreadTask.DoTerminate;
begin
  inherited;
  Synchronize(procedure
    begin
      ...
    end);
end;

[Klaus01]

Zitat von himitsu:

Zitat:

Der ThreadTask wird ausserhalb erstellt

Und wo ist dann die fCriticalSection, beim Durchlaufen und vorallem Löschen der Items?

Wie gesagt, wenn du im Constructor und Execute deinen Code mal auskommentierst, bleiben dann die Handle gleich?

Brauche ich beim Löschen eine CriticalSection?
fRunningTasks ist eine Liste die nur im Threadpool existiert.

Die TaskList ist eine Liste die von aussen befüllt wird.
Dort sind "geparkten" ThreadTasks enthalten.

Aus der TaskListe werden die ThreadTasks in die fRunningTaskliste verschoben und anschließend gestartet.
Gut beim Verschieben aus der TaskList in die fRunningTasks Liste, da könnte eine criticalSection fehlen.

Den onTerminate Konstrukt werde ich mir nochmals anschauen.

Wenn der Excute-code leer ist erhöht sich die Anzahl der Handles auch.
Auch wenn der Constructor leer ist, erhöht sich die Anzahl der Handles.

Grüße
Klaus

[Blup]

destructor TThreadTask.Destroy;

Fehlt da nicht ein "inherited"?

[himitsu]

Zitat von Blup:

Fehlt da nicht ein "inherited"?

Ja.

[Klaus01]

sodele..

ich habe nun das komische onTerminate Konstrukt abgeändert
und das fehlende inherited in der Destroy-Methode hinzugefügt.

.. und es schaut sehr viel besser aus.
Es wird die Anzahl der Handles nur um 1 pro Durchlauf erhöht.
.. das werde ich dann auch noch finden.

Danke für die Hilfe.

Grüße
Klaus