QSystemSemaphore Class

Documentation des fonctions membres

QSystemSemaphore::QSystemSemaphore(const QNativeIpcKey &key, int initialValue = 0, QSystemSemaphore::AccessMode mode = Open)

Demande un sémaphore système pour l’ key spécifiée. Les paramètres initialValue et mode sont utilisés selon les règles suivantes, qui dépendent du système.

Sous Unix, si l’ mode est Open et que le système dispose déjà d’un sémaphore identifié par key, ce sémaphore est utilisé et son nombre de ressources n’est pas modifié, c’est-à-dire que initialValue est ignoré. Mais si le système ne dispose pas encore d’un sémaphore identifié par key, il crée un nouveau sémaphore pour cette clé et définit son nombre de ressources à initialValue.

Sous Unix, si l’ mode est Create et que le système dispose déjà d’un sémaphore identifié par key, ce sémaphore est utilisé et son nombre de ressources est défini sur initialValue. Si le système ne dispose pas encore d’un sémaphore identifié par key, il crée un nouveau sémaphore pour cette clé et définit son nombre de ressources sur initialValue.

Sous Windows, ` mode ` est ignoré, et le système tente toujours de créer un sémaphore pour la clé spécifiée ` key`. Si le système ne dispose pas encore d’un sémaphore identifié par ` key`, il crée ce sémaphore et définit son nombre de ressources à ` initialValue`. Mais si le système dispose déjà d’un sémaphore identifié par ` key `, il utilise ce sémaphore et ignore ` initialValue`.

Le paramètre mode n’est utilisé que sur les systèmes Unix pour gérer le cas où un sémaphore survit à un plantage de processus. Dans ce cas, le processus suivant qui allouera un sémaphore avec la même valeur key obtiendra le sémaphore qui a survécu à l’arrêt, et à moins que mode ne soit Create, le compteur de ressources ne sera pas réinitialisé à initialValue mais conservera la valeur initiale qui lui avait été attribuée par le processus qui s’est arrêté.

Voir également acquire() et key().

QSystemSemaphore::QSystemSemaphore(const QString &key, int initialValue = 0, QSystemSemaphore::AccessMode mode = Open)

Demande un sémaphore système identifié par la clé héritée key.

[noexcept] QSystemSemaphore::~QSystemSemaphore()

Le destructeur détruit l'objet ` QSystemSemaphore `, mais le sémaphore système sous-jacent n'est pas supprimé du système, sauf si cette instance de ` QSystemSemaphore ` est la dernière existante pour ce sémaphore système.

Deux effets secondaires importants du destructeur dépendent du système. Sous Windows, si la fonction ` acquire()` a été appelée pour ce sémaphore mais pas ` release()`, la fonction ` release()` ne sera pas appelée par le destructeur, et la ressource ne sera pas libérée lorsque le processus se terminera normalement. Il s'agirait là d'un bogue du programme susceptible de provoquer un blocage (deadlock) dans un autre processus tentant d'acquérir la même ressource. Sous Unix, les ressources acquises qui ne sont pas libérées avant l'appel du destructeur sont automatiquement libérées à la sortie du processus.

bool QSystemSemaphore::acquire()

Acquiert l'une des ressources protégées par ce sémaphore, s'il y en a une de disponible, et renvoie ` true`. Si toutes les ressources protégées par ce sémaphore ont déjà été acquises, l'appel se bloque jusqu'à ce que l'une d'entre elles soit libérée par un autre processus ou thread disposant d'un sémaphore avec la même clé.

Si la valeur false est renvoyée, une erreur système s’est produite. Appelez error() pour obtenir une valeur de type QSystemSemaphore::SystemSemaphoreError indiquant quelle erreur s’est produite.

Voir également release().

QSystemSemaphore::SystemSemaphoreError QSystemSemaphore::error() const

Renvoie une valeur indiquant si une erreur s'est produite et, le cas échéant, de quelle erreur il s'agit.

Voir également errorString().

QString QSystemSemaphore::errorString() const

Renvoie une description textuelle de la dernière erreur survenue. Si la fonction error() renvoie un objet de type ` error value`, appelez cette fonction pour obtenir une chaîne de caractères décrivant l'erreur.

Voir aussi error().

QString QSystemSemaphore::key() const

Renvoie la clé héritée attribuée à ce sémaphore système. Cette clé correspond au nom sous lequel le sémaphore est accessible depuis d'autres processus.

Voir également setKey().

QNativeIpcKey QSystemSemaphore::nativeIpcKey() const

Renvoie la clé attribuée à ce sémaphore système. La clé correspond au nom sous lequel le sémaphore est accessible depuis d'autres processus.

Vous pouvez utiliser la clé native pour accéder à des sémaphores système qui n’ont pas été créés par Qt, ou pour accorder l’accès à des applications non-Qt. Voir Clés IPC natives pour plus d’informations.

Voir également ` setNativeKey()`.

bool QSystemSemaphore::release(int n = 1)

Libère les ressources n protégées par le sémaphore. Renvoie true sauf en cas d'erreur système.

Exemple : créer un sémaphore système comportant cinq ressources ; les acquérir toutes, puis les libérer toutes.

QSystemSemaphore sem(QSystemSemaphore::platformSafeKey("market"), 5, QSystemSemaphore::Create);
for (int i = 0; i < 5; ++i)  // acquire all 5 resources
    sem.acquire();
sem.release(5);              // release the 5 resources

Cette fonction permet également de « créer » des ressources. Par exemple, immédiatement après la séquence d’instructions ci-dessus, supposons que l’on ajoute l’instruction suivante :

sem.release(10);          // "create" 10 new resources

Dix nouvelles ressources sont désormais protégées par le sémaphore, en plus des cinq qui existaient déjà. En règle générale, vous n’utilisez pas cette fonction pour créer davantage de ressources.

Voir également acquire().

void QSystemSemaphore::setKey(const QString &key, int initialValue = 0, QSystemSemaphore::AccessMode mode = Open)

Cette fonction fonctionne de la même manière que le constructeur. Elle reconstruit cet objet QSystemSemaphore. Si la nouvelle clé key est différente de l'ancienne, l'appel de cette fonction équivaut à appeler le destructeur du sémaphore avec l'ancienne clé, puis à appeler le constructeur pour créer un nouveau sémaphore avec la nouvelle clé key. Les paramètres initialValue et mode sont définis de la même manière que pour le constructeur.

Voir également QSystemSemaphore() et key().

void QSystemSemaphore::setNativeKey(const QNativeIpcKey &key, int initialValue = 0, QSystemSemaphore::AccessMode mode = Open)

Cette fonction fonctionne de la même manière que le constructeur. Elle reconstruit cet objet ` QSystemSemaphore `. Si la nouvelle clé ` key ` est différente de l'ancienne, l'appel de cette fonction équivaut à appeler le destructeur du sémaphore avec l'ancienne clé, puis à appeler le constructeur pour créer un nouveau sémaphore avec la nouvelle clé ` key`. Les paramètres ` initialValue ` et ` mode ` sont définis de la même manière que pour le constructeur.

Cette fonction est utile si la clé native a été partagée depuis un autre processus. Voir Clés IPC natives pour plus d’informations.

Voir également ` QSystemSemaphore()` et ` nativeIpcKey()`.