Wie kann eine Thread-Synchronisierung in C 0x erreicht werden, ohne Semaphoren zu verwenden?

C 0x ohne Semaphoren: Thread-Synchronisierung erreichen

C 0x führt verschiedene Verbesserungen ein, aber eine bemerkenswerte Auslassung ist die Einbeziehung von Semaphoren. Semaphoren sind für die Thread-Synchronisierung unerlässlich, da sie es Threads ermöglichen, Ereignisse zu signalisieren und auf deren Abschluss zu warten.

Problemstellung

Wie können wir ohne Semaphoren einen Mechanismus implementieren? für die Thread-Synchronisierung, wie in der folgenden Verwendung von POSIX-Semaphoren veranschaulicht:

void thread0(...)
{
  doSomething0();

  event1.wait();

  ...
}

void thread1(...)
{
  doSomething1();

  event1.post();

  ...
}

Lösungsverwendung Mutex und Bedingungsvariable

Eine effektive Methode besteht darin, eine Semaphor-ähnliche Funktionalität mithilfe eines Mutex und einer Bedingungsvariablen zu erstellen. Hier ist der Code:

#include <mutex>
#include <condition_variable>

class semaphore {
    std::mutex mutex_;
    std::condition_variable condition_;
    unsigned long count_ = 0; // Initialized as locked.

public:
    void release() {
        std::lock_guard<decltype> lock(mutex_);
        ++count_;
        condition_.notify_one();
    }

    void acquire() {
        std::unique_lock<decltype> lock(mutex_);
        while(!count_) // Handle spurious wake-ups.
            condition_.wait(lock);
        --count_;
    }

    bool try_acquire() {
        std::lock_guard<decltype> lock(mutex_);
        if(count_) {
            --count_;
            return true;
        }
        return false;
    }
};</decltype></decltype></decltype></condition_variable></mutex>

Verwendung

Dieses benutzerdefinierte Semaphor kann auf folgende Weise verwendet werden:

semaphore event1;

void thread0(...)
{
  doSomething0();

  event1.acquire();

  ...
}

void thread1(...)
{
  doSomething1();

  event1.release();

  ...
}

Verglichen Nur zu Mutex

Dieser Ansatz bietet mehrere Vorteile gegenüber der Verwendung eines Mutex allein:

• Es beseitigt die Mehrdeutigkeit beim Erwerb und der Freigabe desselben Mutex in verschiedenen Threads, was zu einem Deadlock führen kann.
• Es stellt sicher, dass Thread1 den Mutex nicht vor Thread0 erhält.
• Es bietet eine zusätzliche try_acquire()-Methode für die nicht blockierende Erfassung Versuche.

Durch die Verwendung dieser benutzerdefinierten Semaphor-Implementierung können Sie effektiv eine Thread-Synchronisierung in C 0x ohne explizite Semaphor-Unterstützung erreichen.

Das obige ist der detaillierte Inhalt vonWie kann eine Thread-Synchronisierung in C 0x erreicht werden, ohne Semaphoren zu verwenden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!