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'adresse key spécifiée. Les paramètres initialValue et mode sont utilisés conformément aux règles suivantes, qui dépendent du système.

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

Sous Unix, si 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 fixé à initialValue. Si le système ne dispose pas déjà d'un sémaphore identifié par key, il crée un nouveau sémaphore pour cette clé et fixe son nombre de ressources à initialValue.

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

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

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 acquire() a été appelé pour ce sémaphore mais pas release(), release() ne sera pas appelé par le destructeur et la ressource ne sera pas libérée lorsque le processus se termine normalement. Il s'agit d'un bogue de programme qui pourrait être à l'origine d'un blocage dans un autre processus essayant 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 lorsque le processus se termine.

bool QSystemSemaphore::acquire()

Acquiert l'une des ressources gardées par ce sémaphore, s'il y en a une de disponible, et renvoie true. Si toutes les ressources gardé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 ayant un sémaphore avec la même clé.

Si false est renvoyé, une erreur système s'est produite. Appelez error() pour obtenir une valeur de QSystemSemaphore::SystemSemaphoreError qui indique quelle erreur s'est produite.

Voir aussi 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 aussi errorString().

QString QSystemSemaphore::errorString() const

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

Voir aussi error().

QString QSystemSemaphore::key() const

Renvoie la clé patrimoniale attribuée à ce sémaphore système. La clé est le nom par lequel les autres processus peuvent accéder au sémaphore.

Voir aussi setKey().

QNativeIpcKey QSystemSemaphore::nativeIpcKey() const

Renvoie la clé attribuée à ce sémaphore système. La clé est le nom par lequel le sémaphore peut être accédé par d'autres processus.

Vous pouvez utiliser la clé native pour accéder aux 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 aussi setNativeKey().

bool QSystemSemaphore::release(int n = 1)

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

Exemple : Créer un sémaphore système ayant cinq ressources ; les acquérir toutes et les libérer.

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 peut également "créer" des ressources. Par exemple, immédiatement après la séquence d'instructions ci-dessus, supposons que nous ajoutions l'instruction suivante : "Dix nouvelles ressources sont maintenant gardées par le sémaphore :

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

Dix nouvelles ressources sont maintenant gardées par le sémaphore, en plus des cinq qui existaient déjà. Vous ne devriez normalement pas utiliser cette fonction pour créer des ressources supplémentaires.

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 l'objet QSystemSemaphore. Si le nouveau key est différent de l'ancienne clé, appeler cette fonction revient à appeler le destructeur du sémaphore avec l'ancienne clé, puis à appeler le constructeur pour créer un nouveau sémaphore avec le nouveau key. Les paramètres initialValue et mode sont ceux définis pour le constructeur.

Voir aussi 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 l'objet QSystemSemaphore. Si le nouveau key est différent de l'ancienne clé, appeler cette fonction revient à appeler le destructeur du sémaphore avec l'ancienne clé, puis à appeler le constructeur pour créer un nouveau sémaphore avec le nouveau key. Les paramètres initialValue et mode sont ceux définis pour le constructeur.

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

Voir aussi QSystemSemaphore() et nativeIpcKey().