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

在 Linux 中的实现方式：

Synchronisation

Beim Synchronisierungsmechanismus wird die Ausführung mehrerer Ausführungsthreads oder -prozesse koordiniert, um sicherzustellen, dass sie in einer bestimmten Reihenfolge ausgeführt werden oder unter bestimmten Bedingungen warten. Zu den gängigen Synchronisationsmechanismen gehören Semaphore, Bedingungsvariablen, Barrieren usw.

Konstruktionsprinzip

1. Atomere Operationen: Atomare Operationen beziehen sich auf unteilbare Operationen. Entweder werden alle ausgeführt oder keine davon. Bei der Synchronisierung sind atomare Operationen ein wesentliches Element, um die sichere Ausführung eines Threads oder Prozesses zu gewährleisten.

2. Gegenseitiger Ausschluss: Ein Hauptziel der Synchronisierung besteht darin, einen sich gegenseitig ausschließenden Zugriff auf gemeinsam genutzte Ressourcen sicherzustellen, d. h. nur ein Thread oder Prozess kann gleichzeitig auf gemeinsam genutzte Ressourcen zugreifen, um Race Conditions zu vermeiden.

3. Bedingung warten: Der Synchronisationsmechanismus muss normalerweise bedingtes Warten unterstützen, dh ein Thread oder Prozess wartet, bis eine bestimmte Bedingung erfüllt ist, und andere Threads oder Prozesse benachrichtigen den wartenden Thread, um die Ausführung fortzusetzen, wenn die Bedingung erfüllt ist Koordination der Thread-Implementierung zwischen.

4. Aufbewahrung der Reihenfolge: Synchronisierung kann auch die Kontrolle der Ausführungsreihenfolge umfassen, um sicherzustellen, dass Threads oder Prozesse in der erwarteten Reihenfolge ausgeführt werden, wodurch die Korrektheit und Zuverlässigkeit des Programms sichergestellt wird.

Implementierung in Linux

• Semaphore: Durch Semaphore können Ressourcen gezählt werden, um sicherzustellen, dass nur eine begrenzte Anzahl von Threads oder Prozessen gleichzeitig auf gemeinsam genutzte Ressourcen zugreifen kann. Unter Linux werden Semaphore normalerweise mit Funktionen wie sem_init、sem_wait 和 sem_post bedient.
• Bedingungsvariablen: Bedingungsvariablen ermöglichen es einem Thread, zu warten, bis eine bestimmte Bedingung erfüllt ist, und benachrichtigt zu werden, die Ausführung fortzusetzen, wenn die Bedingung erfüllt ist. Unter Linux werden Bedingungsvariablen normalerweise mit Funktionen wie pthread_cond_init、pthread_cond_wait 和 pthread_cond_signal manipuliert.

Mutex

Gegenseitiger Ausschluss ist ein Mechanismus, der den gegenseitigen ausschließlichen Zugriff auf gemeinsam genutzte Ressourcen gewährleistet. In einer Umgebung mit mehreren Threads oder mehreren Prozessen sind Mutex-Sperren der häufigste gegenseitige Ausschlussmechanismus.

Konstruktionsprinzip

1. Mutex-Sperre: Eine Mutex-Sperre ist eine Sperre, die sicherstellt, dass nur ein Thread gleichzeitig auf gemeinsam genutzte Ressourcen zugreifen kann. Wenn ein Thread die Mutex-Sperre erhält, müssen andere Threads warten.
2. Kritischer Abschnitt: Ein kritischer Abschnitt ist ein Codeabschnitt, der auf gemeinsam genutzte Ressourcen zugreifen kann und in den jeweils nur ein Thread eintreten kann. Mutex-Sperren werden häufig zum Schutz kritischer Abschnitte verwendet.
3. Deadlock-Vermeidung: Beim Entwerfen eines Mutex-Mechanismus müssen Sie die Deadlock-Vermeidung berücksichtigen, um sicherzustellen, dass das System aufgrund der Verwendung von Mutex-Sperren nicht in einen unentlasteten Wartezustand gerät.

Implementierung in Linux

• Mutex: Unter Linux werden Mutex-Sperren normalerweise über Funktionen wie pthread_mutex_init、pthread_mutex_lock 和 pthread_mutex_unlock betrieben. Sie ermöglichen es Threads, kritische Abschnitte sicher zu betreten und zu verlassen.
• Spinlock: Ein Spinlock ist eine Sperre, die die CPU nicht aufgibt, sondern in einer Schleife immer wieder eincheckt, während sie auf einen Mutex wartet. Unter Linux werden Spinlocks üblicherweise über spin_lock 和 spin_unlock bedient.

Die oben genannten sind einige gängige Mechanismen, um unter Linux Synchronisierung und gegenseitigen Ausschluss zu erreichen. Die konkrete Wahl hängt von den Anforderungen der Anwendung und den Kompromissen zwischen Leistung und Wartbarkeit ab.

Im folgenden Beispielcode zeige ich die Verwendung von Mutex- und Bedingungsvariablen zur Implementierung eines einfachen Synchronisierungsmechanismus. Hier werden die zugehörigen Funktionen der POSIX-Thread-Bibliothek verwendet.

#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. Initialisieren Sie den Mutex: Verwenden Sie PTHREAD_MUTEX_INITIALIZER 或者 pthread_mutex_init, um den Mutex zu initialisieren.
2. Sperren und Entsperren: Verwenden Sie pthread_mutex_lock 来上锁，使用 pthread_mutex_unlock zum Entsperren. Der Zugriff auf gemeinsam genutzte Ressourcen innerhalb eines kritischen Abschnitts sollte zwischen Sperren und Entsperren erfolgen.
3. Mutex zerstören: Verwenden Sie pthread_mutex_destroy, um einen Mutex zu zerstören, wenn er nicht mehr benötigt wird.

Der obige Code zeigt, wie eine Mutex-Sperre verwendet wird, um einen sicheren Zugriff auf gemeinsam genutzte Ressourcen zu gewährleisten und Race Conditions zu verhindern.

Das obige ist der detaillierte Inhalt von. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!