Hallo Zusammen,

ich bin irgendwie am Verzweifeln mit diesen Thread's

Ich baue gerade einen Applikation, welche bei mir alle IT Geräte auf Erreichbarkeit überwachen soll ~ 700 Stück

Das funzt soweit auch ganz gut wenn ich den Ping in einen Thread auslagere.
Jetzt ist jedoch das Problem, wenn ein Gerät nicht erreichbar ist, dauert der durchlauf ziemlich lange (TCP-Timeout)

Mein Idee war jetzt einfach in einem Array von Thread den Ping Thread mehrfach aufzurufen

zusammenfalten · markieren

Delphi-Quellcode:

procedure TPingThread.DoSomething;
begin
  OutputDebugString(Pchar(' Idx:' + inttostr(fidx) + ' START '  + fIPName+ ' ' + ClassName));

   FOnline :=false;
   FLastseen :=0;

   if (length(FIPAdr) >= 7) and (Pos('.',FIPAdr) >=2) then //1.1.1.1
   begin
      bIPio := true;
   end else begin
      bIPio := false;
      DoneFlag := false;
// OutputDebugString(Pchar(ClassName + ' DNSLookUP ' + fIPName));
      Ping1.DnsLookup(FIPName);
       while not DoneFlag do
       begin
           Sleep(FSleepTime);
           Ping1.ProcessMessages;
           if Terminated then break;
       end;
   end;

   if bIPio then
   begin
       DoneFlag := False;
// OutputDebugString(Pchar(ClassName + ' PING ' + fIPName));
       Ping1.Address := FIPAdr;
       Ping1.Ping;
       while not DoneFlag do
       begin
           Sleep(FSleepTime);
           Ping1.ProcessMessages;
           if Terminated then break;
       end;
   end;

    // ist der Flag Terminated gesetzt, Schleife verlassen (* Unit1)
    Synchronize(UpDateDaten);
  OutputDebugString(Pchar(' Idx:' + inttostr(fidx) + ' Finish '  + fIPName+ ' ' + ClassName));
end;

Das funktioniert auch, nur leider habe ich nicht den gewünschten Effekt, dass die Thread parallel arbeiten
sondern werden nacheinander abgearbeitet, warum?

In der IDE steht unter "Thread Status" auch Angehalten, obwohl ich den Thread beim Starten extra nochmals starte

zusammenfalten · markieren

Delphi-Quellcode:

        for Idx := 0 to TimerThreadDaten.Count - 1 do
       begin
          if TimerThreadDaten.Done[Idx] then continue;
          if TimerThreadDaten.ThreadPointer(Idx) <> nil then continue;

            IPName :=TimerThreadDaten.GetName(idx);
            //ipname := 'fritz.box';
            ip :=TimerThreadDaten.GetIP(idx);
            if TimerThreadDaten.ThreadCount < MaxThreads then
            begin
               SubThread := TPingThreadForMain.Create(IPName,ip,Idx,32);
               SubThread.OnTerminate := self.ThreadDone;
               SubThread.FreeOnTerminate := true;
               subthread.Resume;
               TimerThreadDaten.ThreadPointer(idx,SubThread);
            end;

       end;

Wie schaffe ich es mit VCL Möglichkeiten Thread parallel zu starten
habe mir auch das Beispiel NonVCL LuckiePing
angesehen, nur da verstehe ich nur Bahnhof.

Mfg
Hannes

hmm also ich würde das Problem anderes angehen:

Du machst einen Workerpool (Threadpool) mit sagen wir mal 100 Threads.
Diese hollen sich aus einer Workliste immer eine Adresse und pingen diese dann, wenn sie fertig sind die nächste ...

Das hat vorallem den vorteil das die Threads nicht dauernd erstellt bzw. terminiert werden müssen.

Siehe dazu auch: http://www.delphipraxis.net/internal...t.php?t=111982

Zitat von Totaler:

In der IDE steht unter "Thread Status" auch Angehalten, obwohl ich den Thread beim Starten extra nochmals starte

Das ist normal den:
Dieser Status wird erst bei einem Breakpoint in diesem Thread aktualisiert. Bei einem Breakpoint wird der Thread aber angehalten. Somit ist dieser wenn du den status siehst immer angehalten.

Hallo Alex,

danke für die schnelle Antwort.
Das mit dem Pool muss ich mir mal anschauen, ist eine gute IDEE.

Aber anhand der Klasse mit dem WorkerPoolThread ist mir folgendes aufgefallen.

Wenn man die Threads Synchronized aufruft, werden diese nach einander abgearbeitet, ansonstern laufen Sie parallel.

Irgendewie habe ich das mit dem Synchronized noch nicht ganz verstanden, wann ist es notwendig dies zu verwenden
Zitat aus Quelltext von Workerthread

markieren

Delphi-Quellcode:

(*----------------------------------------------------------------------------*
| TWorkerThreadJob ist die Basisklasse für einen Job. Implementiere in der  |
| Execute-Methode die zu erledigenden Arbeiten. Setze ggf. Synchronized      |
| auf False, wenn keinerlei VCL-Controls oder Anzeigen verwendet werden.    |
| Setze UseCOMObjects auf True, falls der Job auf COM-Objekte zugreift.      |
| Dies trifft z.B. bei der Verwendung von ADO-Objekten zu.                  |
*----------------------------------------------------------------------------*)

In seinem Beispiel schreibt er die Ergebnisse in ein MEMO macht dies Default aber unSynchronized und man sieht das die Daten fast zeitgleich im Memo auftauchen.
Sobald ich Synchronized auf True setzte (wollte einfach mal testen) ist der gleiche Effekt wie bei mir, dass die Threads nicht parallel arbeiten sonder nach einander.
Wann muss ich jetzt Synchronized auf TRUE setzen, ist MEMO keine VCL Komponente?

Bei meinem Problem möchte ich mit den mehreren Threads verhindern, dass ein nicht erreichbarer Teilnehmer den kompletten Scann aufhält.

Schönen Advents Samstag
Hans

Hallo

ich habe jetzt die CLASSE von

Zitat:

Siehe dazu auch: http://www.delphipraxis.net/topic1119 ... ad+der+diener+im+hintergrund.html

in meine Anwendung eingebaut.

und es sieht ganz gut aus.

Bezüglich der Synchronisierung habe ich jetzt so einiges gelesen,
und habe mich jetzt dazu entschlossen ohne Synchronisierung zu arbeiten, weil ich einen Datenpool erstelle, auf welchen nur die Threads schreibzugriff haben.
(Das Locking der Threads untereinander, macht ja die Classe)

Der Hauptthread (Main Formular) überprüft alle Sekunde den Datenpool
und übergibt die Daten an den VirtualStringTree.

Vielen Dank für die Hilfe

Gruß und einen schönen 4ten Advent.

Zitat von Totaler:

Wenn man die Threads Synchronized aufruft, werden diese nach einander abgearbeitet, ansonstern laufen Sie parallel.

Genau. Das ist der Sinn dieser Eigenschaft.

Zitat von Totaler:

Irgendewie habe ich das mit dem Synchronized noch nicht ganz verstanden, wann ist es notwendig dies zu verwenden
...In seinem Beispiel schreibt ...

Das Beispiel ist hier etwas irreführend. Es demonstriert die Verwendung der WorkerthreadThread.Notify-Methode, um Kontrollausgaben 'mal eben' zu implementieren.

Es bleibt jedoch dabei: Wenn im Job auf VCL-Komponenten zugegriffen wird, und diese Zugriffe zu einem Neuzeichnen führen, dann *muss* 'Synchronized' auf TRUE gesetzt werden. Sonst eben nicht. Vielleicht sollte die Eigenschaft 'UsesVCLObjects' heißen, analog zu 'UsesCOMObjects'.

Zitat von alzaimar:

Es bleibt jedoch dabei: Wenn im Job auf VCL-Komponenten zugegriffen wird, und diese Zugriffe zu einem Neuzeichnen führen, dann *muss* 'Synchronized' auf TRUE gesetzt werden. Sonst eben nicht. Vielleicht sollte die Eigenschaft 'UsesVCLObjects' heißen, analog zu 'UsesCOMObjects'.

Danke nochmals für die Beschreibung, dass mit 'UsesVCLObjects' finde ich verständlicher

Ich habe aber auch schon VCL Componenten ohne'Synchronized' verändert und es gab keinen ABSTURZ
War das Zufall?

Schöne Grüße
Hannes