Quelle est la différence entre les variables de condition et les sémaphores sous Linux

Différences : 1. L'utilisation de variables de condition peut réveiller tous les serveurs en même temps, mais les sémaphores ne peuvent pas se réveiller ; 2. Les sémaphores ont toujours une valeur (état), tandis que les variables de condition n'ont aucune valeur et il n'y a aucun endroit pour enregistrer le nombre. de fois qu'un signal est envoyé. Il n'y a pas de place pour enregistrer le nombre de retours d'attente ; 3. Le but du sémaphore est de synchroniser entre les processus, et le but de la variable de condition est de synchroniser entre les threads.

L'environnement d'exploitation de ce tutoriel : système linux5.9.8, ordinateur Dell G3.

Variable de condition

La variable de condition (cond) est une méthode couramment utilisée dans les programmes multithread pour implémenter la logique "attendre ---> réveiller", et est un mécanisme de synchronisation entre les processus. Les variables de condition sont utilisées pour bloquer un thread jusqu'à ce que la condition soit remplie et déclenchée. Généralement, les variables de condition et les mutex sont utilisés en même temps.

Les variables de condition générale ont deux états :

(1) Un/plusieurs threads se bloquent en attendant "la condition de la variable de condition est établie"

(2) Un autre thread notifie "lorsque la variable de condition est établie" ; fils.

Utilisation de variables de condition :

#include <pthread.h>

struct msg {
    struct msg *m_next;
    /* ... more stuff here ... */
};
struct msg *workq;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;

void
process_msg(void)
{
    struct msg *mp;

    for (;;) {
        pthread_mutex_lock(&qlock);
        while (workq == NULL)
            pthread_cond_wait(&qready, &qlock);
        mp = workq;
        workq = mp->m_next;
        pthread_mutex_unlock(&qlock);
        /* now process the message mp */
    }
}

void
enqueue_msg(struct msg *mp)
{
    pthread_mutex_lock(&qlock);
    mp->m_next = workq;
    workq = mp;
    pthread_mutex_unlock(&qlock);
    pthread_cond_signal(&qready);
}

Bien sûr, vous pouvez également utiliser le code suivant lors du déclenchement de variables de condition. Les deux méthodes ont leurs propres avantages et inconvénients

void
enqueue_msg(struct msg *mp)
{
    pthread_mutex_lock(&qlock);
    mp->m_next = workq;
    workq = mp;
    pthread_cond_signal(&qready);
    pthread_mutex_unlock(&qlock);
}

Semaphore

Le sémaphore est un type particulier. L'accès aux variables est atomique.

Seules deux opérations sont autorisées dessus :

(1) Attendre le sémaphore

Lorsque la valeur du sémaphore est 0, le programme attend ; lorsque la valeur du sémaphore est supérieure à 0, le sémaphore est décrémenté de 1 et le programme continue de courir.

(2) Envoyer le sémaphore

Ajoutez 1 à la valeur du sémaphore.

Remarque : Linux fournit un ensemble d'API de sémaphore, qui sont déclarées dans le fichier d'en-tête sys/sem.h.

linux La différence entre les variables de condition et les sémaphores :

(1) L'utilisation de variables de condition peut réveiller tous les serveurs en même temps, mais ce sémaphore n'a pas cette fonction, ce qui semble être la plus grande différence.

(2) Le sémaphore a toujours une valeur (statut), mais pas la variable de condition. Il n'y a aucun endroit pour enregistrer combien de fois il a été réveillé (envoi d'un signal), et il n'y a aucun endroit pour enregistrer comment. plusieurs fois il a été réveillé (attendre revient). Du point de vue de l'implémentation, un sémaphore peut être implémenté en utilisant mutex + compteur + variable de condition. Le sémaphore ayant un état, si vous souhaitez une synchronisation précise, le sémaphore peut avoir des fonctionnalités particulières. Les sémaphores peuvent résoudre le problème de la perte de réveil dans les variables de condition.

(3) Le but des sémaphores est la synchronisation inter-processus, et le but des verrous mutex et des variables de condition est la synchronisation inter-thread, mais les sémaphores peuvent également être utilisés entre les threads, et les verrous mutex et les variables de condition peuvent également être utilisés entre processus. Les décisions doivent être prises en fonction des circonstances réelles. Le scénario le plus utile pour les sémaphores est d'indiquer la quantité de ressources disponibles.

Une phrase classique :

Un mutex est un cas particulier de sémaphore L'essence d'un mutex est un verrou.

Recommandations associées : "Tutoriel vidéo Linux"

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!