Wie überprüft man, ob der Prozess auf Red Hat Linux läuft?

Question

Ich habe eine geänderte Klasse verwendet, die ich gefunden habe, um zu überprüfen, ob eine andere Instanz des gleichen Prozesses bereits ausgeführt wird. Das Problem besteht darin, dass die Methode zur Überprüfung des Prozesses eine weitere Instanz desselben Prozesses hinzufügt.

Wenn meine Anwendung startet, wird ein neuer Prozess-ID erstellt und ist sichtbar mit:

ps -A | grep "AppName" 

Damit erhalte ich ein seit Eintrag zurückgekehrt, überprüfe ich dann für eine andere Instanz der Anwendung mit:

QString strCMD = "ps -A | grep \"" + mcstrAppName + "\""; 
QProcess objProc; 
objProc.start("bash", QStringList() << "-c" << strCMD); 

if (objProc.waitForStarted() != true || objProc.waitForFinished() != true) { 
    mcpobjApp->exit(cleanExit(-1, "Unable to determine if another instance is running!")); 
    return; 
} 

Sobald die ‚Start‘ Methode eine andere Instanz derselben Anwendung in der Prozesstabelle wieder, verifiziert genannt wird angezeigt wird, mit:

ps -A | grep "AppName" 

Es erscheinen nun zwei Einträge mit jeweils einer anderen PID. Ich habe auch versucht:

QString strOptions = "-A | grep \"" + mcstrAppName + "\""; 
QProcess objProc; 
objProc.start("ps", QStringList() << strOptions); 

Das Ergebnis ist das gleiche, zwei Einträge in der Prozesstabelle.

Gibt es eine Möglichkeit, die Prozesstabelle für eine andere Instanz zu überprüfen, ohne eine zusätzliche Instanz hinzuzufügen?

Answer 1

Ich empfehle die Verwendung einer PID-Datei. Es ist das Standardverfahren für Daemons unter Linux.

int createPidFile(const char *pidFile, int flags) 
{ 
    int fd; 
    char buf[BUF_SIZE]; 
    fd = open(pidFile, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); 
    if (fd == -1) 
     errExit("Could not open PID file %s", pidFile); 
    if (flags & CPF_CLOEXEC) 
    { 
     /* Set the close-on-exec file descriptor flag */ 
     flags = fcntl(fd, F_GETFD); /* Fetch flags */ 
     if (flags == -1) 
      errExit("Could not get flags for PID file %s", pidFile); 
     flags |= FD_CLOEXEC; /* Turn on FD_CLOEXEC */ 
     if (fcntl(fd, F_SETFD, flags) == -1) /* Update flags */ 
      errExit("Could not set flags for PID file %s", pidFile); 
    } 
    return fd; 
} 

Quelle Die Linux Programming Interface

Dies erzeugt eine Datei und sperrt es so kein anderer Prozess öffnen kann. Es wird beim Beenden als so nah angezeigt, dass die Datei geschlossen wird, wenn der Prozess durch normale oder abnormale Beendigung beendet wird. Wenn eine Instanz Ihres Programms bereits ausgeführt wird, schlägt diese Funktion fehl und Sie können einfach beenden.

EDIT: Die PID-Datei sollte in der temporären Partition sein. Der spezifische Standort hängt von Ihrer Distribution ab. Sehen Sie sich einfach Ihr System an, wo andere Daemons ihre PID-Dateien erstellen.

Answer 2

Ich glaube, Sie versuchen zu validieren, dass nur "eine" Instanz Ihrer Anwendung auf einmal ausgeführt werden kann.

Um dies zu erreichen, benötigen Sie etwas wie QtSingleApplication.

Eine andere Alternative, d. H. SingleApplication.

Answer 3

Die eigentliche Lösung, die ich verwendet, die ich selbst geschrieben habe, Prototyp: clsSingleInstance.h:

class clsSingleInstance : public QObject { 
Q_OBJECT 

public: 
    explicit clsSingleInstance(const QString& strAppName, QApplication* pobjApp); 

public slots: 
    void check(); 

private: 
    const int mcintDelay = 3000; 
    const QString mcstrAppName; 

    qint64 mint64PID; 
    QApplication const* mcpobjApp; 
    QTimer* mptmrCheck; 

    Q_DISABLE_COPY(clsSingleInstance); 
}; 

Implementierung, clsSingleInstance.cpp:

#include "clsSingleInstance.h" 
    /** 
    * @brief clsSingleInstance::clsSingleInstance 
    * @param strAppName : The application name as it will appear in the process list 
    * @param pobjApp : Pointer to the applicaiton instance 
    */ 
    clsSingleInstance::clsSingleInstance(const QString& strAppName 
             ,QApplication* pobjApp) 
             :QObject(pobjApp) 
             ,mcstrAppName(strAppName) 
             ,mcpobjApp(pobjApp) { 
    //Save the process ID 
     mint64PID = mcpobjApp->applicationPid(); 
    //Run check now to determine if another instance is running 
     check(); 
    //Set-up timer to check for another instance regularly 
     mptmrCheck = new QTimer(this); 

     if (mptmrCheck != NULL) { 
      connect(mptmrCheck, SIGNAL(timeout()), this, SLOT(check())); 
      mptmrCheck->start(mcintDelay); 
     } 
    } 
    /** 
    * @brief clsSingleInstance::check 
    * Checks application instances running 
    */ 
    void clsSingleInstance::check() { 
     const QString cstrCheckFile = clsMainWin::mcszConfigPath 
             + mcstrAppName + ".pid"; 
     QFile objPID(cstrCheckFile); 

     if (objPID.exists() == true) { 
    //Check the file date/time stamp 
      QDateTime dtCreated = QFileInfo(cstrCheckFile).created() 
        ,dtNow = QDateTime::currentDateTime(); 
      qint64 int64Created = dtCreated.toMSecsSinceEpoch() 
        ,int64Now = dtNow.toMSecsSinceEpoch() 
        ,int64Diff = int64Now - int64Created; 
    //Is the file current and being updated? 
      if (int64Diff < (mcintDelay * 2)) { 
    //PID file is live, read it 
       if (objPID.open(QIODevice::ReadOnly) == true) { 
    //PID file exists, it should only contain a single ID 
        QByteArray arybytContent = objPID.readAll(); 
        QString strContent = arybytContent.trimmed(); 
        objPID.close(); 

        if (strContent.toLongLong() != mint64PID) { 
         qInfo("Another instance already present..."); 
         exit(EXIT_FAILURE); 
        } 
       } 
      } 
     } 
    //Create/update PID file 
     if (objPID.open(QIODevice::WriteOnly) == true) { 
      QString strPID = QString::number(mint64PID); 
      objPID.write(strPID.toLatin1()); 
      objPID.close(); 
     } 
    }