Rausfinden wie oft ein Programm läuft

[DelTurbo]

Hi,

leider finde ich in google nix. Deshalb frage ich einfach mal. Ich möchte ein Programm mehrmals starten. Ich weiss wie ich rausfinde ob das programm schon läuft, aber leider nicht wie oft das schon läuft. Wär super wenn mir da mal jemand helfen könnte.

Vielen dank im voraus

Rausfinden ob das Programm schon läuft mache ich wie folgt.

Delphi-Quellcode:

      Initialization //Verhindern, dass das Programm mehrmals gestartet wird
          mHandle := CreateMutex(nil, True, 'Projekt1.exe');
              if GetLastError = ERROR_ALREADY_EXISTS then
              begin
           MessageDlg('Das Programm läuft schon!', mtWarning, [mbOK], 0);
                Halt;
              end;
      finalization
         if mHandle <> 0 then CloseHandle(mHandle);

[himitsu]

Mutex = es kann nur Einen geben

Wenn es den Mutex also schon gibt, dann gibt es eine andere Anwendung, mit einem gleichnamigen Mutex im selben Kontext, in welchem man den neuen Mutex erstellen will.
> also geht hier nur "Einer oder Keiner"

Willst du die Anzahl wissen und mehrere zulassen, dann wirst du irgendwas nutzen müssen, welches ebenfalls global existiert und über eine Art Referenzzzählung verfügt.

[DelTurbo]

Zitat:

Zitat von himitsu (Beitrag 1081929)

Willst du die Anzahl wissen und mehrere zulassen, dann wirst du irgendwas nutzen müssen, welches ebenfalls global existiert und über eine Art Referenzzzählung verfügt.

Das habe ich vor. Aber leider weiss ich nicht wie ich das anstellen soll. Das beispiel oben habe ich hauptsächlich drangehängt, falls mal jemand sowas sucht.

[WM_CLOSE]

Du könntest folgendes Versuchen:

Delphi-Quellcode:

      var
        i:Integer=0;      
      Initialization //Zählen wie oft das Programm gestartet wird
          repeat
              mHandle := CreateMutex(nil, True, 'InstanzMeinerApplikation'+ IntToStr(i));
              Inc(i);
          until GetLastError <> ERROR_ALREADY_EXISTS;
          MessageBox(0, PChar('Das Programm wurde'+IntToStr(i)+'mal gestartet') , 'MeinProg', MB_OK)
      finalization
         if mHandle <> 0 then CloseHandle(mHandle);

Man bemerke, dass das eine ziemlich fiese möglichkeit ist. Es geht bestimmt auch anders

PS: Den MessageDlg würde ich im initialization-Abschnitt nicht riskieren. lieber eine hübsche API-Funktion

[shmia]

In der JCL gibt es die Unit JclAppInst, mit der man die Anzahl der laufenden Instanzen zählen und auch begrenzen kann.
Ausserdem können die Instanzen untereinander auch Daten austauschen.
Das funktioniert sehr gut; nur auf einem Terminal Server klappt der Datenaustausch leider nicht.

Wenn du die JCL benützen magst, ist der Programmieraufwand sehr gering.

[DelTurbo]

Erstmal danke für die antworten. Jcl hab ich natürlich drauf ;)

Soll das dann damit gehen: JvAppInstances1.AppInstances ?

Leider kommt ein fehler (unbekannt) wenn ich das bei var eintrage.

test :TJclAppInstances;

Ich dachte mir das so.....

Delphi-Quellcode:

var
   test :TJclAppInstances;
begin
   test:=JvAppInstances1.AppInstances;
end;

Was mach ich nun wieder falsch??? Ich dachte in TJclAppInstances steht dann z.b. ein Integer drinne der die anzahl der laufenden Programme hat. War das wieder zu einfach gedacht?

Danke im voraus

Edit: Ich habs gefunden. JvAppInstances1.AppInstances.InstanceCount

Vielen dank für den stubs in die richtige richtung!

[DeddyH]

Nach einem kurzen Blick in die Unit sollte das so funktionieren:

Delphi-Quellcode:

var
  test: TJclAppInstances;
begin
  test := TJclAppInstances.Create;
  try
    ShowMessage(IntToStr(test.GetInstanceCount));
  finally
    test.Free;
  end;

[DelTurbo]

Nein. Dort kommt dann "Undefinierter Bezeichner TJclAppInstances". Die Unit steht aber in uses drinne.

Mit JvAppInstances1.AppInstances.InstanceCount klappt es auch sehr gut. Ich merke mir den wert beim start des programms. Schon habe ich was ich wollte.

Nochmal danke....

[himitsu]

Wenn JvAppInstances1 geht, dann hast du vermutlich ein TJvAppInstances auf die Form gezogen?
Wenn ja, dann braucht man es natürlich nich nochmal manuell zu instantiieren.

PS: Es gibt TJclAppInstances und auch eine TJvAppInstances, welcher vermutlich auch in unterschiedlichen Units rumgammeln (Jcl ist das nichtvisuelle Jedi-CL und Jv ist die visuelle JEDI-VCL)

Zitat:

TJvAppInstance encapsulates the TJclAppInstance class

Delphi-Quellcode:

JvAppInstances1.AppInstances.GetInstanceCount

oder vielleicht sogar sowas wie

Delphi-Quellcode:

JvAppInstances1.GetInstanceCount

[Aphton]

Für diejenigen, die keine Komponente verwenden wollen, hier, eine Konsolenanwendung für Demozwecke:

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

uses
  Windows;

var
  hFile: THandle;
  Instances: Integer = 0;
  pData: PInteger;

const
  lpFilename: PChar = 'ProjFileSize';

begin
  hFile := OpenFileMapping( FILE_MAP_READ or FILE_MAP_WRITE, True, lpFilename );
  if hFile = ERROR then
    hFile := CreateFileMapping( INVALID_HANDLE_VALUE, NIL, PAGE_READWRITE, 0, 4, lpFilename );
  if hFile <> ERROR then
    try
      pData := MapViewOfFile( hFile, FILE_MAP_READ or FILE_MAP_WRITE, 0, 0, 4 );
      if Assigned( pData ) then
      begin
        try
          Instances := pData^;
          Writeln( Instances, ' instances have already been existing; increasing it...' );
          inc( Instances );
          pData^ := Instances;
          Writeln( 'Increased and updated!' );
          Write( 'Instances = ', Instances, ' (press return to enter the terminating-process)' );
          Readln;
          Instances := pData^;
          Writeln( 'Terminating... decreasing instances' );
          dec( Instances );
          Writeln( 'Instances = ', Instances );
          pData^ := Instances;
          Writeln( 'Decreased and updated!' );
        finally
          UnmapViewOfFile( pData );
        end;
        Write( 'Press any key to exit...' );
        Readln;
      end;
    finally
      CloseHandle( hFile );
    end;
end.

Führe diese Konsolenanwendung einfach mehrmals hintereinander aus, ohne die vorherigen Instanzen zu schließen, um die Instanzenzählung zu sehen!

Have fun!

[rollstuhlfahrer]

Inc und Dec sind aber nicht threadsave, also kann es zu Problemen kommen, wenn 2 Prozesse gleichzeitig versuchen, die Anzahl zu verändern. Besser ist dagegen InterlockedDecrement und InterlockedIncrement.

Bernhard

[Aphton]

Zitat:

Zitat von rollstuhlfahrer (Beitrag 1082012)

Inc und Dec sind aber nicht threadsave, also kann es zu Problemen kommen, wenn 2 Prozesse gleichzeitig versuchen, die Anzahl zu verändern. Besser ist dagegen InterlockedDecrement und InterlockedIncrement.

Bernhard

Ohh, danke für die Information! Hab ich gar nicht bedacht :oops:

[DelTurbo]

Hi,

nochmals danke für die hilfe. Schon kommt ein neues problem. Ich versuche es mal zu erklären.

Ich habe z.b. 5x das prg laufen. Jedes prg kennt seine "nummer" (1-5). Nun beende ich z.b. programm 3. Dann starte ich das programm nochmal. Nun versuche ich seit gestern abend einen weg zu finden, der mir sagt das programm 3 fehlt und das nun neu gestartete programm die 3 annehmen soll.

Mit dieser jedi-hilfe die ich gefunden habe komm ich nicht weiter. http://help.delphi-jedi.org/unit.php?Id=2575

Ich dachte mir das ungefähr so. Eine schleife von 1 bis JvAppInstances1.AppInstances.InstanceCount. Und in der schleife würde ich gerne jeden process abfragen ob er da ist. Sollten z.b. alle 5 da sein, weiss ich das ich einen 6. process aufmachen muss. Sollte einer oder mehr fehlen wollte ich die kleinste nummer nehmen von den fehlenden.

Ich hoffe mir kann da nochmal einer weiterhelfen.

Danke im voraus

[rollstuhlfahrer]

Also so langsam würde ich auf die Unix-Schiene wechseln und das Datei-basiert machen. Windows kennt temporäre Dateien, die nur so lange existieren, wie die Anwendung diese offen hält (oder bis die Anwendung tot ist). Diese Dateien kannst du im TMP-Verzeichnis des Users erstellen. Mit Hilfe von FileExists() kannst du dann rausfinden, welche Anwendung (inkl. Nummer) läuft.

Bernhard

[DelTurbo]

Das wäre eine idee. Ich dachte es geht etwas "eleganter"

[Memnarch]

Also ich würde per Delphi mir einfach sämtliche apps holen(so wies im taskmanager steht) und mir davon den namen der exe holen. Dadurch kannste deine progs zählen.

Wenn dein Prog auch ne Form hat, also keine consolenanwendung ist, wovon ich mal ausgehe), kanst du einfach deiner hauptform ne caption zuweisen. sowas wie

"Name(X)"

X ist hierbei die nummer. wenn du dir also die Fensterliste holst und alle fenster rausholst, die deine exe haben, kannst du deren caption überprüfen und die nummer rausfiltern. Damit bekommste raus welche fehlt.

Für ersteres war es glaub ich "GetWindowList".

MFG
Memnarch

[blutsgeist]

Guten Abend,

da ich im Delphi-Gebiet noch nicht so bewandert bin und gerne so ein Programmzähler für meine Zwecke haben will, bräuchte ich eure Hilfe.

Und zwar geht es um diesen Code:

Zitat:

Zitat von WM_CLOSE (Beitrag 1081936)

Delphi-Quellcode:

      var
        i:Integer=0;      
      Initialization //Zählen wie oft das Programm gestartet wird
          repeat
              mHandle := CreateMutex(nil, True, 'InstanzMeinerApplikation'+ IntToStr(i));
              Inc(i);
          until GetLastError <> ERROR_ALREADY_EXISTS;
          MessageBox(0, PChar('Das Programm wurde'+IntToStr(i)+'mal gestartet') , 'MeinProg', MB_OK)
      finalization
         if mHandle <> 0 then CloseHandle(mHandle);

Ich weiß leider nicht wie ich mHandle deklarien muss. Kann mir da einer weiter helfen?

LG Blutsgeist

[Luckie]

Na ja. mHandle? Was böte sich denn da wohl an? ;) Vielleicht THandle? ;)

[blutsgeist]

Danke für die schnelle Antwort!

THandle gibt wenigstens keine Fehler mehr aus, allerdings wenn ich es compilieren will, bekomme ich immer Fehler angezeigt.

Siehe einfach mal den Screenshot ;-)

LG

[himitsu]

Und woher sollen wir jetzt wissen, das was für eine Zeile sein soll?

Aber meine Glaskugel sagt mit ... du solltest die vorherigen Fehler beheben.
Denn der Fehler ist nicht diese Variable.


PS: Wobei man auch einfach mal nachsehn könne, was CreateMutex als Result für einen Typen vorgibt und für deinen letzen Fehler, was sie für Parameter haben will. :roll:


PSS: Wenn/falls dein Code mal funktioniert ... versuche mal Folgendes:
- Programm mehrmals starten
- das Erste beenden
- nun nochmal Eines starten und schauen was das mein, wie oft es schon gestartet sei. :angle2:

[Luckie]

Und was steht in der angegeben Zeilennummer?

[blutsgeist]

Zeile 32:

Code:

THandle := CreateMutex(nil, True, 'calc.exe'+ IntToStr(i));

Zeile 37:

Code:

if THandle <> 0 then CloseHandle(THandle);

[Luckie]

Da stimmen aber alle Klammern. Kommentiere mal den ganzen Initialization abschnitt aus und probiere es noch mal.

[himitsu]

CreateMutex = WinAPI

Wenn man sich die Parameter ansieht, dann will das einen PChar (wobei den D2009-XE2 (?) natürlich von PWideChar redet)

Delphi-Quellcode:

'calc.exe'+ IntToStr(i)

= String

Und was sagt dir die eine Fehlerzeile?

[blutsgeist]

Entweder bin ich zu doof oder ich blick nicht mehr durch.

Hier mal der gesagte Source:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

var
        i:Integer=0;
      Initialization //Zählen wie oft das Programm gestartet wird
          repeat
              THandle := CreateMutex(nil, True, 'calc.exe'+ IntToStr(i));
              Inc(i);
          until GetLastError <> ERROR_ALREADY_EXISTS;
          MessageBox(0, PChar('Das Programm wurde'+IntToStr(i)+'mal gestartet') , 'MeinProg', MB_OK)
      finalization
         if THandle <> 0 then CloseHandle(THandle);

end.

Glieder ich THandle := CreateMutex(nil, True, 'calc.exe'+ IntToStr(i)); und if THandle <> 0 then CloseHandle(THandle); aus, läuft das Programm. Sind die beiden aber wieder drin, zickt das nur rum -.-

[Luckie]

Argh.

Delphi-Quellcode:

var
  mHandle: THandle;

Hast du noch nie eine Variable deklariert?

[blutsgeist]

Paar Variablen habe ich schon Deklariert, allerdings ist das schon eine weile her -.-

Ausbildung und so ging einfach vor ...

Vielen Dank für eure Zeit, die ich in anspruch genommen habe.
Ich werde allerdings heute Delphi ruhen lassen... Sehe den Wald vor lauter Bäumen nicht mehr......

LG

[Delphi-Laie]

Zitat:

Zitat von WM_CLOSE (Beitrag 1081936)

Du könntest folgendes Versuchen:

Delphi-Quellcode:

      var
        i:Integer=0;      
      Initialization //Zählen wie oft das Programm gestartet wird
          repeat
              mHandle := CreateMutex(nil, True, 'InstanzMeinerApplikation'+ IntToStr(i));
              Inc(i);
          until GetLastError <> ERROR_ALREADY_EXISTS;
          MessageBox(0, PChar('Das Programm wurde'+IntToStr(i)+'mal gestartet') , 'MeinProg', MB_OK)
      finalization
         if mHandle <> 0 then CloseHandle(mHandle);

Man bemerke, dass das eine ziemlich fiese möglichkeit ist.

Inwiefern ist denn diese Möglichkeit "fies"?

[DelTurbo]

Hi,
ich habe es damals mit TJvAppInstances gemacht. Das ding kann aber nochmehr. Legs einfach mal drauf und spiel bissl mit rum. So lerne ich immer wenn ich was nicht weiss. Komme ich nicht weiter, dann google ich. zu 80% finde ich dann einen link nach hier, wo das steht was ich brauche.