Problem beim Programmneustart mit Instanzkontrolle

[Dalai]

Ich mache es so: der/das Mutex wird erst erzeugt, nachdem alle Programmparameter abgearbeitet sind. Die zweite Instanz wird mit einem bestimmten Parameter gestartet und wenn der gefunden wird, schließt die zweite Instanz die erste bereits laufende.

Mal in Code-Form (Auszug aus der .dpr):

Delphi-Quellcode:

begin
    if (ParamCount > 0) then
    begin
        Params:= ParamStr(1);
        if (Params = 'runas') then
        begin
            SendMessage(StrToInt(ParamStr(2)), WM_CLOSE, 0, 0);
        end;
    end;

    hMutex:= CreateMutex(nil, True, PRODUCTNAME + PRODUCTNAME + PRODUCTCOPYRIGHT);
    if GetLastError = ERROR_ALREADY_EXISTS then
    (* Weiterer hierfür nicht relevanter Code *)

    if hMutex <> 0 then
        CloseHandle(hMutex);
end.

Ich glaube, ParamStr(2) war die PID oder so, damit die Message nur an die laufende erste Instanz gesendet wird.

MfG Dalai

[Sir Rufo]

Zitat von Opa Knack:

Wenn ich das richtig verstehe (sorry, Musicman, aber in D2006 ist CharInSet nicht verfügbar, somit konnte ich das nicht ausprobieren), muss ich den Mutex freigeben, bevor ich ihn erzeuge (was ja auch logisch ist).

Das ist richtig

Zitat von Opa Knack:

Dann ergibt sich aber aus meiner Sicht das Problem, dass ich den Neustart ja vom Programm aus initiiere, der Mutex also noch besteht, und das dieser erst freigegeben werden kann, wenn das Programm auch beendet ist. Oder sehe ich das falsch?

Das siehst du richtig, dass du das falsch siehst

Zitat von Opa Knack:

Ich habe inzwischen ausprobiert, ob ich den Mutex dadurch freigeben kann, dass ich vor Programmende versuche, ihn neu zu erzeugen und bei Vorhandensein über CloseHandle freizugeben, leider jedoch ohne Erfolg.

Du hast vom Seil etwas abgeschnitten und festgestellt, dass es immer noch zu kurz ist?

Zitat von Opa Knack:

Hat jemand noch eine andere praktikable Idee?

Ja, gib den Mutex vor dem Aufruf von ShellExecute mit CloseHandle frei.

Dann wird das Handle geschlossen (übersetzt heißt CloseHandle -> SchließeHandle).
Wird der Prozess beendet, dann werden alle noch offenen Handles von diesem Prozess automatisch geschlossen.
Aber in diesem Falle musst du den halt vorher manuell freigeben.

Delphi-Quellcode:

  // Nun ja ... wenn schon dann bitte mit Self
  {form1}Self.Close;
  // Da wir aber die Anwendung schließen wollen, müssen wir das HauptFormular schließen, also besser
  Application.MainForm.Close;

  // wozu das? unnötig!
  // application.ProcessMessages; 

  // Hier jetzt das Handle vom Mutex freigeben
  CloseHandle( MyAppMutexHandle );

  // Nicht das Application.Handle übergeben sondern 0
  ShellExecute({Application.Handle} 0, 'open', Pchar(ParamStr(0)), nil, nil, sw_SHOWNORMAL);

[Sir Rufo]

Hier die versprochene Klasse

Delphi-Quellcode:

unit AppMutex;

interface

type
  TAppMutexStrategy = class abstract
  private
    procedure SetActive( const Value : Boolean );
  protected
    function GetActive : Boolean; virtual; abstract;
    procedure AquireMutex; virtual; abstract;
    procedure ReleaseMutex; virtual; abstract;
  public
    destructor Destroy; override;
  end;

  TAppMutex = class
  private
    class var FStrategy : TAppMutexStrategy;
  private
    class procedure SetActive( const Value : Boolean ); static;
    class function GetActive : Boolean; static;
    class destructor Destroy;
  public
    class property Active : Boolean read GetActive write SetActive;
    class procedure SetStrategy( AStrategy : TAppMutexStrategy );
  end;

  TNamedAppMutexStrategy = class( TAppMutexStrategy )
  private
    FHandle : Cardinal;
    FName :   string;
  protected
    procedure AquireMutex; override;
    procedure ReleaseMutex; override;
    function GetActive : Boolean; override;
    function GetName : string; virtual;
    property Name : string read GetName;
  public
    constructor Create( const AName : string );
  end;

  TLocalAppMutexStrategy = class( TNamedAppMutexStrategy )
  protected
    function GetName : string; override;
  end;

  TGlobalAppMutexStrategy = class( TNamedAppMutexStrategy )
  protected
    function GetName : string; override;
  end;

implementation

uses
  Windows,
  SysUtils;

{ TAppMutex }

class destructor TAppMutex.Destroy;
begin
  FreeAndNil( FStrategy );
end;

class function TAppMutex.GetActive : Boolean;
begin
  Result := FStrategy.GetActive;
end;

class procedure TAppMutex.SetActive( const Value : Boolean );
begin
  FStrategy.SetActive( Value );
end;

class procedure TAppMutex.SetStrategy( AStrategy : TAppMutexStrategy );
begin
  if Assigned( FStrategy )
  then
    FreeAndNil( FStrategy );

  FStrategy := AStrategy;
end;

{ TAppMutexStrategy }

destructor TAppMutexStrategy.Destroy;
begin
  SetActive( False );
  inherited;
end;

procedure TAppMutexStrategy.SetActive( const Value : Boolean );
begin
  if Value = GetActive
  then
    Exit;

  if Value
  then
    AquireMutex
  else
    ReleaseMutex;
end;

{ TNamedAppMutexStrategy }

procedure TNamedAppMutexStrategy.AquireMutex;
var
  LLastError : Cardinal;
begin
  FHandle := CreateMutex( nil, True, PChar( Name ) );

  LLastError := GetLastError;

  if LLastError = ERROR_ALREADY_EXISTS
  then
    begin
      CloseHandle( FHandle );
      FHandle := 0;
    end;
end;

constructor TNamedAppMutexStrategy.Create( const AName : string );
begin
  inherited Create;
  FName := AName;
end;

function TNamedAppMutexStrategy.GetActive : Boolean;
begin
  Result := ( FHandle <> 0 );
end;

function TNamedAppMutexStrategy.GetName : string;
var
  LIdx : Integer;
begin
  Result   := FName;
  for LIdx := 1 to Length( Result ) do
    begin
      if not CharInSet( Result[LIdx], ['0' .. '9', 'A' .. 'Z', 'a' .. 'z', '-'] )
      then
        Result[LIdx] := '_';
    end;
end;

procedure TNamedAppMutexStrategy.ReleaseMutex;
begin
  CloseHandle( FHandle );
  FHandle := 0;
end;

{ TLocalAppMutexStrategy }

function TLocalAppMutexStrategy.GetName : string;
begin
  Result := 'Local\' + inherited;
end;

{ TGlobalAppMutexStrategy }

function TGlobalAppMutexStrategy.GetName : string;
begin
  Result := 'Global\' + inherited;
end;

end.

Im Einsatz so

Delphi-Quellcode:

program MutexTest;

uses
  Forms,
  MainView_Form in 'MainView_Form.pas' {MainView} ,
  AppMutex in 'AppMutex.pas',
  AlertView_Form in 'AlertView_Form.pas' {AlertView};

{$R *.res}

begin
  // Strategie einstellen
  TAppMutex.SetStrategy( TGlobalAppMutexStrategy.Create( '6D274674-150A-490E-B8D0-726C6D556F29' ) );
  // Aktivieren
  TAppMutex.Active := True;

  // Überprüfung
  if not TAppMutex.Active
  then
  begin
    TAlertView.Create( nil ).ShowModal;
    Halt;
  end;

  Application.Initialize;
  Application.MainFormOnTaskbar := True;
  Application.CreateForm( TMainView, MainView );
  Application.Run;

end.

[musicman56]

Hallo,

vielen Dank Sir Rufo, ich werd's mal ausprobieren

[hathor]

Das Problem "OneInstance" hatte ich heute auch und habe es im DPR-File gelöst.
Wenn das zuerst gestartete Programm minimiert ist, wird es angezeigt.
Funktioniert auch unter WIN 8.0.

Delphi-Quellcode:

program TEST1;

uses
  Forms, Windows,
  Unit1 in 'Unit1.pas' {Form1};

{$R *.res}

procedure SwitchToThisWindow(h1: hWnd; x: bool); stdcall; external user32 Name
'SwitchToThisWindow'; {x = false: Size unchanged, x = true: normal size}

var
  PreviousHandle : THandle;
begin
  PreviousHandle := Windows.FindWindow(NIL,'MyProg'); //MyProg = Form1.caption
  if PreviousHandle = 0 then
  begin
    Application.Initialize;
    Application.CreateForm(TForm1, Form1);
    Application.Run;
  end
  else
 begin
    if Windows.IsIconic(PreviousHandle) then
        Windows.ShowWindow(PreviousHandle, SW_RESTORE);
    SwitchToThisWindow(PreviousHandle, TRUE);
    SetForegroundWindow(PreviousHandle);
    SetWindowPos(PreviousHandle,
      HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE or SWP_NOSIZE or SWP_SHOWWINDOW);
 end;
end.

[Opa Knack]

Danke für die hilfreichen Tipps, ich werde mich hineinknien. Übrigens funktioniert es mit

Delphi-Quellcode:

  // Nun ja ... wenn schon dann bitte mit Self
  {form1}Self.Close;
  // Da wir aber die Anwendung schließen wollen, müssen wir das HauptFormular schließen, also besser
  Application.MainForm.Close;

  // wozu das? unnötig!
  // application.ProcessMessages;

  // Hier jetzt das Handle vom Mutex freigeben
  CloseHandle( MyAppMutexHandle );

  // Nicht das Application.Handle übergeben sondern 0
  ShellExecute({Application.Handle} 0, 'open', Pchar(ParamStr(0)), nil, nil, sw_SHOWNORMAL);

nicht. Selbst wenn man MyAppMutexHandle (das logischerweise nicht vorhanden ist) durch den eigentlichen Mutex ersetzt.

[Sir Rufo]

Zitat von Opa Knack:

Danke für die hilfreichen Tipps, ich werde mich hineinknien. Übrigens funktioniert es mit
... nicht. Selbst wenn man MyAppMutexHandle (das logischerweise nicht vorhanden ist) durch den eigentlichen Mutex ersetzt.

Dann machst du irgendwas noch falsch, denn mit dem Freigeben des Mutex-Handle kann dieser Mutex wieder belegt werden.
(getestet)

Ähm, ja logisch ist das nicht bekannt - hätte ich besser schreiben sollen DatAppMutexDingensBumsHandleWatDuDaVerstecktInDerUnitRumliegenHast

Da du folgenden Code in deiner unit hast

Delphi-Quellcode:

if mHandle <> 0 then CloseHandle(mHandle)

gehe ich auch davon aus, dass du weißt wie man ein Handle freigibt und dass man dazu auch das Handle selber braucht

[Furtbichler]

Zitat von hathor:

...

Delphi-Quellcode:

...
  PreviousHandle := Windows.FindWindow(NIL,'MyProg'); //MyProg = Form1.caption

Das ist nicht allgemeingültig, denn viele Programme haben im Titel des Hauptformulars variable Informationen (z.B. den Namen der aktuell geladenen Datei, User- oder DB-infos etc.), d.h. Du weißt beim Programmstart nicht immer, was im Titel des Hauptformulars steht. Zudem musst Du deinen Code bei jeder Verwendung individuell anpassen.

Zum Thema 'eine Instanz und Neustart' wollte ich noch meinen Senf dazugeben:

Das Kürzeste, was ich diesbezüglich auf meinem Sperrmüll gefunden habe, ist eine Unit, die man einfach per 'uses' einbindet und dadurch einen Mehrfachstart verhindert.

Delphi-Quellcode:

unit OneInstance;
interface
implementation
uses Windows, SysUtils;

var
  hMutex: Cardinal;

initialization
  hMutex := CreateMutex(nil, True, PChar(UpperCase(ExtractFileName(ParamStr(0)))));
  if GetLastError = ERROR_ALREADY_EXISTS then Halt;
end.

Ich persönlich halte das für vollkommen ausreichend.

Mit 'Restart' wäre das diese Kleinstunit (Eben reingefrickelt):

Delphi-Quellcode:

unit OneInstance;
interface
Procedure Restart;
implementation
uses Windows, SysUtils, ShellApi;

var
  hMutex: Cardinal;

Procedure Restart;
Begin
  CloseHandle(hMutex);
  ShellExecute({Application.Handle} 0, 'open', Pchar(ParamStr(0)), nil, nil, sw_SHOWNORMAL);
  Halt; // Brutalstmögliches Beenden der eigenen Anwendung.
End;

initialization
  hMutex := CreateMutex(nil, True, PChar(UpperCase(ExtractFileName(ParamStr(0)))));
  if GetLastError = ERROR_ALREADY_EXISTS then Halt;
end.

Allerdings starten sich meine Programme nicht neu. Ich halte das für falsch. Ein Programm hat eine bestimmte Aufgabe und wenn es sie nicht erfüllen kann, dann soll sich das Programm beenden.

Wenn ich eine 24/7-Umgebung benötige, sorge ich (z.B. durch eine BAT-Datei), das die Anwendung neu gestartet wird.

Code:

:label
MyProg.exe
goto label

So kann ich einerseits die Anwendung in einer Endlosschleife am Leben halten, andererseits die gleiche Anwendung ohne Klimmzüge laufen lassen, bis sie abschmiert. Falls sie nun ständig abschmiert, kann ich die Endlosschleife einfach unterbrechen, indem ich die Batch-Datei beende (das Fenster schließe). Mit Selbstneustart benötige ich den Taskmanager, auf den ich aber auch nicht immer Zugriff habe.

Ich will nicht sagen, das das besser ist, aber es ist -für mich- so einfacher. In kritischen Umgebungen habe ich einen Sentinel, also eine Anwendung, die im Hintergrund bestimmte Prozesse überwacht und periodisch prüft, ob diese ansprechbar oder 'abgekackt' sind, d.h. hängen. Wenn ja, wird der Prozess gekillt und die Anwendung/Prozess neu gestartet. Eine zu überwachende Anwendung kann dem Sentinel auch sagen, das sie für immer sich beenden möchte, sodaß dieser die Überwachung einstellt.

So richtig hat mir das alles nie gefallen, denn eine Anwendung sollte immer laufen können. Leider geht das nicht immer (schlechte Treiber, externe DLL usw.)

Senfertig.

[hathor]

Ich habe mein DPR-File etwas geändert - vielleicht kann es jemand brauchen:

Delphi-Quellcode:

program MyProg;

uses
  Forms, Windows, SysUtils,
  Unit1 in 'Unit1.pas' {Form1};

{$R *.res}

procedure SwitchToThisWindow(h1: hWnd; x: bool); stdcall; external user32 Name
'SwitchToThisWindow'; {x = false: Size unchanged, x = true: normal size}

var
  hMutex: Cardinal;
  PreviousHandle : THandle;

BEGIN
  hMutex := CreateMutex(nil, True, PChar(UpperCase(ExtractFileName(ParamStr(0)))));
  if GetLastError = ERROR_ALREADY_EXISTS then
  begin
  PreviousHandle := Windows.FindWindow(NIL,PChar(UpperCase(ExtractFileName(ParamStr(0)))));
    if Windows.IsIconic(PreviousHandle) then
                Windows.ShowWindow(PreviousHandle, SW_RESTORE);
    SwitchToThisWindow(PreviousHandle, TRUE);
    SetForegroundWindow(PreviousHandle);
    SetWindowPos(PreviousHandle,
                HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE or SWP_NOSIZE or SWP_SHOWWINDOW);
  end else
  begin
    Application.Initialize;
    Application.MainFormOnTaskbar := True;
    Application.CreateForm(TForm1, Form1);
    Application.Run;
  end;
end.

[musicman56]

Hallo,

hMutex := CreateMutex(nil, True, PChar(UpperCase(ExtractFileName(ParamStr(0))))); wie ist das eigentlich, wenn ParamStr(0) Sonderzeichen wie "(" ")" "&", Leerzeichen usw. enthält. Funktioniert der Mutex dann noch richtig?

Was mir außerdem nicht ganz optimal erscheint ist die Tatsache, dass mit ParamStr(0) zwar verhindert wird, dass dieselbe Exe zeimal gestartet wird, aber nicht eine weitere Instanz desselben Programmes in einem anderen Ordner. Das zu verhindern kommt bei mir zumindest sehr häufig vor.

Es ist der Grund dafür, dass ich in meiner Unit zwei Möglichkeiten habe, den Mutex zu erzeugen: Einmal mit ParamStr(0) wenn mich dieser Sachverhalt nicht stört, und zusätzlich eine Funktion mit vorgegebenem Mutexnamen, den ich meistens von der Applikation ableite, zum Beispiel dem Application.Title.