Comment empêcher l'exécution de plusieurs instances de votre application C/C ?

Création d'applications à instance unique en C ou C

Dans le domaine du développement logiciel, il est souvent souhaitable de restreindre l'exécution d'une application à une seule instance, garantissant qu’un seul processus est autorisé à s’exécuter à un moment donné. Pour y parvenir, diverses techniques peuvent être utilisées, tournant principalement autour des verrous de fichiers, des mutex et d'autres mécanismes de synchronisation.

Verrouillage de fichiers

Une approche consiste à verrouiller des fichiers, comme démontré dans l'extrait de code ci-dessous :

<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>

Ici, open() est utilisé pour créer un fichier nommé everything.pid et obtenir son descripteur de fichier, tandis que flock() tente d'acquérir un verrou exclusif, garantissant qu'une seule instance à la fois peut détenir un verrou en écriture sur le fichier.

Approche basée sur les mutex

Une autre option consiste à exploiter les mutex, qui fournissent un verrouillage plus flexible mécanisme dans un environnement multithread :

<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>

Ici, pthread_mutex_init() initialise le mutex en utilisant les attributs spécifiés dans attr, tandis que pthread_mutex_lock() et pthread_mutex_unlock() effectuent respectivement des opérations de verrouillage et de déverrouillage, garantissant que un seul thread peut exécuter la section critique.

Socket de domaine Unix

Une technique plus avancée consiste à créer et à lier un socket de domaine Unix à l'aide d'un nom de socket prédéfini :

<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>

Ici, socket() crée un nouveau socket, tandis que bind() tente de le lier au nom de socket stocké dans unixaddr. Si l'opération de liaison échoue avec EADDRINUSE, cela indique qu'une autre instance de l'application est déjà en cours d'exécution.

Le choix de l'approche à utiliser dépend des exigences spécifiques de l'application et du niveau de fiabilité et de performances souhaité. Le verrouillage de fichiers fournit une solution simple et facile à mettre en œuvre, tandis que les mutex offrent plus de flexibilité dans un environnement multithread et que les sockets de domaine Unix offrent une approche plus résiliente capable de gérer les informations de processus obsolètes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!