Wie verhindern Sie, dass mehrere Instanzen Ihrer C/C-Anwendung ausgeführt werden?

Einzelinstanzanwendungen in C oder C erstellen

Im Bereich der Softwareentwicklung ist es oft wünschenswert, die Ausführung einer Anwendung einzuschränken auf eine einzelne Instanz, wodurch sichergestellt wird, dass jeweils nur ein Prozess ausgeführt werden darf. Um dies zu erreichen, können verschiedene Techniken eingesetzt werden, die sich in erster Linie um Dateisperren, Mutexe und andere Synchronisierungsmechanismen drehen.

Dateisperre

Ein Ansatz ist die Dateisperre. wie im folgenden Codeausschnitt gezeigt:

<code class="c">#include <sys/file.h>
#include <errno.h>

int pid_file = open("/var/run/whatever.pid", O_CREAT | O_RDWR, 0666);
int rc = flock(pid_file, LOCK_EX | LOCK_NB);
if(rc) {
    if(EWOULDBLOCK == errno)
        ; // another instance is running
}
else {
    // this is the first instance
}</code>

Hier wird open() verwendet, um eine Datei mit dem Namen „whatever.pid“ zu erstellen und ihren Dateideskriptor abzurufen, während flock() versucht, eine exklusive Sperre zu erhalten, um dies sicherzustellen dass jeweils nur eine Instanz eine Schreibsperre für die Datei halten kann.

Mutex-basierter Ansatz

Eine weitere Option besteht darin, Mutexe zu nutzen, die eine flexiblere Sperre ermöglichen Mechanismus innerhalb einer Multithread-Umgebung:

<code class="c">#include <pthread.h>

pthread_mutex_t mutex;
pthread_mutexattr_t attr;

pthread_mutexattr_init(&attr);
pthread_mutex_init(&mutex, &attr);

pthread_mutex_lock(&mutex);
// critical section code
pthread_mutex_unlock(&mutex);</code>

Hier initialisiert pthread_mutex_init() den Mutex mit den in attr angegebenen Attributen, während pthread_mutex_lock() und pthread_mutex_unlock() Sperr- bzw. Entsperrvorgänge ausführen, um dies sicherzustellen Nur ein Thread kann den kritischen Abschnitt ausführen.

Unix-Domänen-Socket

Eine fortgeschrittenere Technik besteht darin, einen Unix-Domänen-Socket mit einem vordefinierten Socket-Namen zu erstellen und zu binden:

<code class="c">#include <sys/socket.h>

int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
int rc = bind(sockfd, (struct sockaddr*)&unixaddr, sizeof(unixaddr));
if(rc) {
    if(errno == EADDRINUSE)
        ; // another instance is running
}
else {
    // this is the first instance
}</code>

Hier erstellt socket() einen neuen Socket, während bind() versucht, ihn an den in unixaddr gespeicherten Socket-Namen zu binden. Wenn der Bindungsvorgang mit EADDRINUSE fehlschlägt, weist dies darauf hin, dass bereits eine andere Instanz der Anwendung ausgeführt wird.

Die Wahl des zu verwendenden Ansatzes hängt von den spezifischen Anforderungen der Anwendung und dem gewünschten Maß an Zuverlässigkeit und Leistung ab. Das Sperren von Dateien bietet eine unkomplizierte und leicht zu implementierende Lösung, während Mutexe mehr Flexibilität in einer Multithread-Umgebung bieten und Unix-Domänen-Sockets einen robusteren Ansatz bieten, der mit veralteten Prozessinformationen umgehen kann.

Das obige ist der detaillierte Inhalt vonWie verhindern Sie, dass mehrere Instanzen Ihrer C/C-Anwendung ausgeführt werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!