Mécanisme de synchronisation et d'exclusion mutuelle sous Linux

在多进程或多线程的操作系统环境中，同步和互斥是关键的概念，用于确保共享资源的正确访问。下面是同步和互斥的设计原理以及

在 Linux 中的实现方式：

Synchronisation

Le mécanisme de synchronisation est le processus de coordination de l'exécution de plusieurs threads ou processus d'exécution pour garantir qu'ils s'exécutent dans un certain ordre ou attendent dans des conditions spécifiques. Les mécanismes de synchronisation courants incluent les sémaphores, les variables de condition, les barrières, etc.

Principe de conception

1. Opérations atomiques : Les opérations atomiques font référence à des opérations indivisibles, soit toutes sont exécutées, soit aucune d'entre elles n'est exécutée. En synchronisation, les opérations atomiques sont un élément essentiel pour garantir l'exécution sûre d'un thread ou d'un processus.

2. Exclusion mutuelle : L'un des objectifs clés de la synchronisation est de garantir un accès mutuellement exclusif aux ressources partagées, c'est-à-dire qu'un seul thread ou processus peut accéder aux ressources partagées en même temps pour éviter les conditions de concurrence.

3. Condition en attente : Le mécanisme de synchronisation doit généralement prendre en charge l'attente conditionnelle, c'est-à-dire qu'un thread ou un processus attend jusqu'à ce qu'une certaine condition soit remplie, et d'autres threads ou processus notifient au thread en attente de poursuivre l'exécution lorsque la condition est remplie. coordination de la mise en œuvre des threads entre.

4. Préservation de l'ordre : La synchronisation peut également impliquer le contrôle de l'ordre d'exécution pour garantir que les threads ou les processus s'exécutent dans l'ordre attendu, garantissant ainsi l'exactitude et la fiabilité du programme.

Implémentation sous Linux

• Sémaphore : Grâce aux sémaphores, les ressources peuvent être comptées pour garantir que seul un nombre limité de threads ou de processus peuvent accéder aux ressources partagées en même temps. Sous Linux, les sémaphores fonctionnent généralement à l'aide de fonctions telles que sem_init、sem_wait 和 sem_post.
• Variables de condition : Les variables de condition permettent à un thread d'attendre qu'une certaine condition soit remplie et d'être averti pour continuer l'exécution lorsque la condition est remplie. Sous Linux, les variables de condition sont généralement manipulées à l'aide de fonctions telles que pthread_cond_init、pthread_cond_wait 和 pthread_cond_signal.

Mutex

L'exclusion mutuelle est un mécanisme utilisé pour garantir un accès mutuellement exclusif aux ressources partagées. Dans un environnement multithread ou multiprocessus, les verrous mutex constituent le mécanisme d'exclusion mutuelle le plus courant.

Principe de conception

1. Verrou mutex : Un verrou mutex est un verrou utilisé pour garantir qu'un seul thread peut accéder aux ressources partagées en même temps. Lorsqu'un thread acquiert le verrou mutex, les autres threads doivent attendre.
2. Section critique : Une section critique est une section de code qui peut accéder à des ressources partagées, et un seul thread peut y accéder en même temps. Les verrous Mutex sont souvent utilisés pour protéger les sections critiques.
3. Évitement des blocages : Lors de la conception d'un mécanisme mutex, vous devez envisager d'éviter les blocages pour garantir que le système ne tombe pas dans une attente non soulagée en raison de l'utilisation de verrous mutex.

Implémentation sous Linux

• Mutex : Sous Linux, les verrous mutex sont généralement opérés via des fonctions telles que pthread_mutex_init、pthread_mutex_lock 和 pthread_mutex_unlock. Ils permettent aux threads d’entrer et de sortir des sections critiques en toute sécurité.
• Spinlock : Un spinlock est un verrou qui n'abandonne pas le processeur mais continue de vérifier en boucle en attendant un mutex. Sous Linux, les spinlocks sont généralement exploités via spin_lock 和 spin_unlock.

Ci-dessus sont quelques mécanismes courants pour réaliser la synchronisation et l'exclusion mutuelle sous Linux. Le choix spécifique dépend des besoins de l'application et des compromis entre performances et maintenabilité.

Dans l'exemple de code ci-dessous, je vais montrer l'utilisation de variables mutex et de condition pour implémenter un mécanisme de synchronisation simple. Les fonctions associées de la bibliothèque de threads POSIX sont utilisées ici.

#include 
#include 
#include 

#define BUFFER_SIZE 5

int buffer[BUFFER_SIZE];
int count = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_producer = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_consumer = PTHREAD_COND_INITIALIZER;

void *producer(void *arg) {
    for (int i = 0; i while (count == BUFFER_SIZE) {
            // 缓冲区满，等待消费者消费
            pthread_cond_wait(&cond_producer, &mutex);
        }

        buffer[count++] = i;
        printf("Produced: %d\n", i);

        // 通知消费者可以消费了
        pthread_cond_signal(&cond_consumer);
        pthread_mutex_unlock(&mutex);
    }

    pthread_exit(NULL);
}

void *consumer(void *arg) {
    for (int i = 0; i while (count == 0) {
            // 缓冲区空，等待生产者生产
            pthread_cond_wait(&cond_consumer, &mutex);
        }

        int item = buffer[--count];
        printf("Consumed: %d\n", item);

        // 通知生产者可以生产了
        pthread_cond_signal(&cond_producer);
        pthread_mutex_unlock(&mutex);
    }

    pthread_exit(NULL);
}

int main() {
    pthread_t producer_thread, consumer_thread;

    // 创建生产者和消费者线程
    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);

    // 等待线程结束
    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);

    // 销毁互斥锁和条件变量
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond_producer);
    pthread_cond_destroy(&cond_consumer);

    return 0;
}

这个简单的示例演示了一个生产者-消费者问题，其中生产者线程负责往缓冲区中生产数据，而消费者线程负责从缓冲区中消费数据。互斥锁 mutex 用于确保对共享资源的互斥访问，而条件变量 cond_producer 和 cond_consumer 用于在缓冲区满或空时进行等待和通知。

请注意，实际应用中的同步和互斥可能更加复杂，具体的设计取决于应用的需求。

下面是一个简单的示例代码，演示了如何使用 Linux 中的 pthread_mutex_t 来实现互斥锁。这个示例中，两个线程共享一个计数器，通过互斥锁确保对计数器的互斥访问。

#include 
#include 

// 共享的计数器
int counter = 0;

// 互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// 线程函数，增加计数器的值
void* increment_counter(void* arg) {
    for (int i = 0; i main() {
    // 创建两个线程
    pthread_t thread1, thread2;
    pthread_create(&thread1, NULL, increment_counter, NULL);
    pthread_create(&thread2, NULL, increment_counter, NULL);

    // 等待线程结束
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    // 销毁互斥锁
    pthread_mutex_destroy(&mutex);

    // 输出最终的计数器值
    printf("Final Counter Value: %d\n", counter);

    return 0;
}

在这个例子中，两个线程并发地增加 counter 变量的值。由于两个线程共享同一个变量，存在竞争条件。互斥锁 mutex 用来确保对 counter 的互斥访问，一个线程在访问 counter 时先上锁，完成后再解锁，这样另一个线程才能进入。

要使用互斥锁，需要注意以下几点：

1. Initialiser le mutex : Utilisez PTHREAD_MUTEX_INITIALIZER 或者 pthread_mutex_init pour initialiser le mutex.
2. Verrouiller et déverrouiller : Utilisez pthread_mutex_lock 来上锁，使用 pthread_mutex_unlock pour déverrouiller. L'accès aux ressources partagées au sein d'une section critique doit se situer entre le verrouillage et le déverrouillage.
3. Détruire un mutex : Utilisez pthread_mutex_destroy pour détruire un mutex lorsqu'il n'est plus nécessaire.

Le code ci-dessus montre comment utiliser un verrou mutex pour garantir un accès sécurisé aux ressources partagées et éviter les conditions de concurrence.

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!