Hallo!

ich habe ein Thread erstellt und eine globale Variable, die eine Instance dieser Threads ist. Eine Funktion erstellt bei Bedarf diesen global deklarierten Thread, der die Daten bearbeitet und dann terminiert. Wie kann ich überprüfen, on der Thread bereits läuft, bevor ich einen neuen Thread erstelle?

Du könntest die Variable als "= nil" deklarieren und später beim erstellen auf nil prüfen...

Hi,

Du könntest beim Start des Programmes und nach dem Durchlauf des Threads die Variable auf nil setzen und in Deiner Funktion darauf prüfen und den Thread nur erstellen, falls die Variable = nil ist.

Jedoch solltest Du dir das mit der "globalen Variable" überlegen, das ist nicht unbedingt der beste Stil. Eventuell reicht ja schon wenn Du die Variable in den Public / Private Abschnitt Deines Formulares oder der entsprechenden Klasse packen...

mfG
mirage228

Darf ich im Thread, z.B. in der Destroy-procedure die Variable, die auf diesen Thread zuweist, auf nil setzen? Geht das?

Natürlich geht das Dann solltest du aber sicher sein, dass zu diesem Zeitpunkt kein anderer Thread auf diese Variable zufreift.

Mir fällt da Singleton Pattern ein:

Hier geht es eigentlich darum, dass du nur eine Instanz/Objekt deiner Klasse erzeugen kannst / darfst.

Wäre hier in deinem Fall eigentlich ganz vorteilhaft.
Wie man es macht ist eigentlich ganz einfach,
du musst nur deine Create Methode private machen, und eine eigene Methode zur Erzeugung deiner Instanz bauen,
die dann deine private Create Methode aufruft, wenn das Objekt = NIL, oder halt den Zeiger auf das Objekt,
also die Objektinstanz zurückgibt.

Falls du dazu noch Fragen hast, helfe ich dir gerne.

Gruß

Zitat von DelphiManiac:

Mir fällt da Singleton Pattern ein:

Hier geht es eigentlich darum, dass du nur eine Instanz/Objekt deiner Klasse erzeugen kannst / darfst.

Wäre hier in deinem Fall eigentlich ganz vorteilhaft.
Wie man es macht ist eigentlich ganz einfach,
du musst nur deine Create Methode private machen, und eine eigene Methode zur Erzeugung deiner Instanz bauen,
die dann deine private Create Methode aufruft, wenn das Objekt = NIL, oder halt den Zeiger auf das Objekt,
also die Objektinstanz zurückgibt.

Falls du dazu noch Fragen hast, helfe ich dir gerne.

Gruß

Das würde mich interessieren. Zum Beispiel, ich habe ein Thread und möchte, dass ständig eine (und nur eine) Instance dieses Threads läuft. wie mache ich das als Singleton?

@romber:

Nunja das Singleton-Muster ist ja dafür da, dass man nur eine Instanz einer Klasse bekommen kann / darf.
Das kann bei manchen modellierten Klassen von Nöten sein.
Du hast ja mit deinem Thread so ein Beispiel, wo wir Singleton anwenden können.
Gut schauen wir uns doch mal einen Standard Thread an:

zusammenfalten · markieren

Delphi-Quellcode:

MyThread = class(TThread)
private
public
  procedure Execute;override;
  constructor Create;
end; // of MyThread = class(TThread)

constructor TMyThread.Create;
begin
  inherited Create(true); // Create Suspended
end; // of constructor TMyThread.Create;
////////////////////////////////////////////////////////////////////////////////

Nun könnten wir X-Objekte erzeugen, über
TMyThread.Create; welches uns ja die Instanz eines Objektes zurück gibt.

Wir müssen aber nun sicherstellen, dass genau das nicht möglich ist.
Es soll nur ein Objekt erstellt werden, und wenn eines erstellt ist, dann soll nur die Referenz des Objektes (das schon
erzeugt worden ist) zurückgegeben werden.

Du hast hier denke ich 2 Möglichkeiten:

1. Du legtst eine globale Variable an (nicht sehr objektorientiert)
2. Du gibst deiner Klasse eine Klassenvariable mit, die im Kontext der Klasse existiert.

Ich würde dir zu 2. raten.

Gut probieren wir es mal aus

zusammenfalten · markieren

Delphi-Quellcode:

MyThread = class(TThread)
private
  constructor Create;
  ??static?? FThreadObject:TThread; // zum speichern der Referenz auf deas "einzigartige" Objekt
public
  procedure Execute;override;
  procedure GetInstance:TMyThread;
end; // of MyThread = class(TThread)

procedure TMyThreadGetInstance:TMyThread;
begin
  if FThreadObject <> NIL then
  begin
    FFThread:=TMyThread.Create;
    result:=FThreadObject;
  end
  else
  begin
    result:=FThreadObject;
  end;
end; // of procedure TMyThreadGetInstance:TMyThread;
///////////////////////////////////////////////////////////////////////////////

constructor TMyThread.Create; // wird versteckt, da jetzt von aussen nicht mehr direkt aufrubar
begin
  inherited Create(true); // Create Suspended
end; // of constructor TMyThread.Create;
////////////////////////////////////////////////////////////////////////////////

Nun kannst du (hoffe ich, da ich es jetzt von C# adaptiert habe, in Delphi könnte es evtl. Unterschiede geben)
so ein Objekt erzeugen

zusammenfalten · markieren

Delphi-Quellcode:

var
ThreadNo1:TMyThread;
ThreadNo2:TMyThread;
ThreadNo3:TMyThread;



...

ThreadNo1:=TMyThread.GetInstance; // Alles der gleiche Thread (bzw das gleiche Objekt der Threadklasse)
ThreadNo2:=TMyThread.GetInstance; // Alles der gleiche Thread (bzw das gleiche Objekt der Threadklasse)
ThreadNo3:=TMyThread.GetInstance; // Alles der gleiche Thread (bzw das gleiche Objekt der Threadklasse)
ThreadNoX:=TMyThread.Create; // Sollte nicht gehen!!!

Hoffe ich konnte dir ein wenig helfen,
falls noch fragen sind, schiess los...

Gruß
DelphiManiac