C ++ 0x hat keine Semaphoren? Wie synchronisiere ich Threads?

Stimmt es, dass C ++ 0x ohne Semaphore kommt? Es gibt bereits einige Fragen zum Stapelüberlauf bezüglich der Verwendung von Semaphoren. Ich benutze sie (Posix-Semaphoren) die ganze Zeit, um einen Thread auf ein Ereignis in einem anderen Thread warten zu lassen:

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

  event1.wait();

  ...
}

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

  event1.post();

  ...
}

Wenn ich das mit einem Mutex machen würde:

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

  event1.lock(); event1.unlock();

  ...
}

void thread1(...)
{
  event1.lock();

  doSomethingth1();

  event1.unlock();

  ...
}

Problem: Es ist hässlich und es kann nicht garantiert werden, dass Thread1 zuerst den Mutex sperrt (Da derselbe Thread einen Mutex sperren und entsperren sollte, können Sie Ereignis1 auch nicht sperren, bevor Thread0 und Thread1 gestartet wurden).

Also, da Boost auch keine Semaphoren hat, was ist der einfachste Weg, um das oben genannte zu erreichen?

Sie können einfach eine aus einem Mutex und einer Bedingungsvariablen erstellen:

#include <mutex>
#include <condition_variable>

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

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

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

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

Basierend auf der Antwort von Maxim Yegorushkin habe ich versucht, das Beispiel im C ++ 11-Stil zu erstellen .

#include <mutex>
#include <condition_variable>

class Semaphore {
public:
    Semaphore (int count_ = 0)
        : count(count_) {}

    inline void notify()
    {
        std::unique_lock<std::mutex> lock(mtx);
        count++;
        cv.notify_one();
    }

    inline void wait()
    {
        std::unique_lock<std::mutex> lock(mtx);

        while(count == 0){
            cv.wait(lock);
        }
        count--;
    }

private:
    std::mutex mtx;
    std::condition_variable cv;
    int count;
};

Ich habe mich entschlossen, das robusteste / generischste C ++ 11-Semaphor zu schreiben, das ich im Stil des Standards so oft wie möglich schreiben konnte (beachten using semaphore = ...Sie, dass Sie normalerweise nur den Namen verwenden würden, der semaphoredem normalen Verwenden von stringnot ähnelt basic_string):

template <typename Mutex, typename CondVar>
class basic_semaphore {
public:
    using native_handle_type = typename CondVar::native_handle_type;

    explicit basic_semaphore(size_t count = 0);
    basic_semaphore(const basic_semaphore&) = delete;
    basic_semaphore(basic_semaphore&&) = delete;
    basic_semaphore& operator=(const basic_semaphore&) = delete;
    basic_semaphore& operator=(basic_semaphore&&) = delete;

    void notify();
    void wait();
    bool try_wait();
    template<class Rep, class Period>
    bool wait_for(const std::chrono::duration<Rep, Period>& d);
    template<class Clock, class Duration>
    bool wait_until(const std::chrono::time_point<Clock, Duration>& t);

    native_handle_type native_handle();

private:
    Mutex   mMutex;
    CondVar mCv;
    size_t  mCount;
};

using semaphore = basic_semaphore<std::mutex, std::condition_variable>;

template <typename Mutex, typename CondVar>
basic_semaphore<Mutex, CondVar>::basic_semaphore(size_t count)
    : mCount{count}
{}

template <typename Mutex, typename CondVar>
void basic_semaphore<Mutex, CondVar>::notify() {
    std::lock_guard<Mutex> lock{mMutex};
    ++mCount;
    mCv.notify_one();
}

template <typename Mutex, typename CondVar>
void basic_semaphore<Mutex, CondVar>::wait() {
    std::unique_lock<Mutex> lock{mMutex};
    mCv.wait(lock, [&]{ return mCount > 0; });
    --mCount;
}

template <typename Mutex, typename CondVar>
bool basic_semaphore<Mutex, CondVar>::try_wait() {
    std::lock_guard<Mutex> lock{mMutex};

    if (mCount > 0) {
        --mCount;
        return true;
    }

    return false;
}

template <typename Mutex, typename CondVar>
template<class Rep, class Period>
bool basic_semaphore<Mutex, CondVar>::wait_for(const std::chrono::duration<Rep, Period>& d) {
    std::unique_lock<Mutex> lock{mMutex};
    auto finished = mCv.wait_for(lock, d, [&]{ return mCount > 0; });

    if (finished)
        --mCount;

    return finished;
}

template <typename Mutex, typename CondVar>
template<class Clock, class Duration>
bool basic_semaphore<Mutex, CondVar>::wait_until(const std::chrono::time_point<Clock, Duration>& t) {
    std::unique_lock<Mutex> lock{mMutex};
    auto finished = mCv.wait_until(lock, t, [&]{ return mCount > 0; });

    if (finished)
        --mCount;

    return finished;
}

template <typename Mutex, typename CondVar>
typename basic_semaphore<Mutex, CondVar>::native_handle_type basic_semaphore<Mutex, CondVar>::native_handle() {
    return mCv.native_handle();
}

in Übereinstimmung mit Posix-Semaphoren würde ich hinzufügen

class semaphore
{
    ...
    bool trywait()
    {
        boost::mutex::scoped_lock lock(mutex_);
        if(count_)
        {
            --count_;
            return true;
        }
        else
        {
            return false;
        }
    }
};

Und ich bevorzuge es sehr, einen Synchronisationsmechanismus auf einer bequemen Abstraktionsebene zu verwenden, anstatt immer das Zusammenfügen einer zusammengefügten Version mit grundlegenderen Operatoren zu kopieren.

Sie können auch cpp11-on-multicore ausprobieren - es verfügt über eine tragbare und optimale Semaphor-Implementierung.

Das Repository enthält auch andere Threading-Extras, die das C ++ 11-Threading ergänzen.

Sie können mit Mutex- und Bedingungsvariablen arbeiten. Sie erhalten exklusiven Zugriff mit dem Mutex. Prüfen Sie, ob Sie fortfahren möchten oder auf das andere Ende warten müssen. Wenn Sie warten müssen, warten Sie in einem Zustand. Wenn der andere Thread feststellt, dass Sie fortfahren können, signalisiert er den Zustand.

In der Boost :: Thread-Bibliothek gibt es ein kurzes Beispiel , das Sie höchstwahrscheinlich einfach kopieren können (die C ++ 0x- und Boost-Thread-Bibliotheken sind sehr ähnlich).

Kann auch ein nützlicher RAII-Semaphor-Wrapper in Threads sein:

class ScopedSemaphore
{
public:
    explicit ScopedSemaphore(Semaphore& sem) : m_Semaphore(sem) { m_Semaphore.Wait(); }
    ScopedSemaphore(const ScopedSemaphore&) = delete;
    ~ScopedSemaphore() { m_Semaphore.Notify(); }

   ScopedSemaphore& operator=(const ScopedSemaphore&) = delete;

private:
    Semaphore& m_Semaphore;
};

Anwendungsbeispiel in der Multithread-App:

boost::ptr_vector<std::thread> threads;
Semaphore semaphore;

for (...)
{
    ...
    auto t = new std::thread([..., &semaphore]
    {
        ScopedSemaphore scopedSemaphore(semaphore);
        ...
    }
    );
    threads.push_back(t);
}

for (auto& t : threads)
    t.join();

C ++ 20 wird endlich Semaphoren haben - std::counting_semaphore<max_count>.

Diese haben (mindestens) die folgenden Methoden:

• acquire() (Blockierung)
• try_acquire() (nicht blockierend, wird sofort zurückgegeben)
• try_acquire_for() (nicht blockierend, dauert eine Dauer)
• try_acquire_until() (Nicht blockierend, benötigt eine Zeit, um den Versuch zu beenden)
• release()

Dies ist noch nicht in cppreference aufgeführt, aber Sie können diese CppCon 2019-Präsentationsfolien lesen oder das Video ansehen . Es gibt auch den offiziellen Vorschlag P0514R4 , aber ich bin mir nicht sicher, ob dies die aktuellste Version ist.

Ich fand, dass shared_ptr und schwaches_ptr, ein langes mit einer Liste, die Arbeit erledigten, die ich brauchte. Mein Problem war, dass ich mehrere Clients hatte, die mit den internen Daten eines Hosts interagieren wollten. In der Regel aktualisiert der Host die Daten selbst. Wenn ein Client dies anfordert, muss der Host die Aktualisierung jedoch beenden, bis keine Clients mehr auf die Hostdaten zugreifen. Gleichzeitig kann ein Client einen exklusiven Zugriff anfordern, sodass weder andere Clients noch der Host diese Hostdaten ändern können.

Wie ich das gemacht habe, habe ich eine Struktur erstellt:

struct UpdateLock
{
    typedef std::shared_ptr< UpdateLock > ptr;
};

Jeder Kunde hätte ein Mitglied von folgenden:

UpdateLock::ptr m_myLock;

Dann hätte der Host ein schwaches_Ptr-Mitglied für Exklusivität und eine Liste von schwachen_Ptrs für nicht exklusive Sperren:

std::weak_ptr< UpdateLock > m_exclusiveLock;
std::list< std::weak_ptr< UpdateLock > > m_locks;

Es gibt eine Funktion zum Aktivieren der Sperre und eine andere Funktion zum Überprüfen, ob der Host gesperrt ist:

UpdateLock::ptr LockUpdate( bool exclusive );       
bool IsUpdateLocked( bool exclusive ) const;

Ich teste in LockUpdate, IsUpdateLocked und regelmäßig in der Update-Routine des Hosts auf Sperren. Das Testen auf eine Sperre ist so einfach wie das Überprüfen, ob der schwache_PTR abgelaufen ist, und das Entfernen von abgelaufenen Dateien aus der m_Locks-Liste (ich mache dies nur während des Host-Updates). Ich kann überprüfen, ob die Liste leer ist. Gleichzeitig wird die automatische Entsperrung automatisch aktiviert, wenn ein Client das shared_ptr zurücksetzt, an dem er festhält. Dies geschieht auch, wenn ein Client automatisch zerstört wird.

Der Gesamteffekt ist, dass Clients selten Exklusivität benötigen (normalerweise nur für Hinzufügungen und Löschungen reserviert). Meistens ist eine Anforderung an LockUpdate (false), dh nicht exklusiv, erfolgreich, solange (! M_exclusiveLock). Und ein LockUpdate (true), eine Anfrage nach Exklusivität, ist nur erfolgreich, wenn sowohl (! ​​M_exclusiveLock) als auch (m_locks.empty ()).

Es könnte eine Warteschlange hinzugefügt werden, um zwischen exklusiven und nicht exklusiven Sperren abzumildern. Bisher gab es jedoch keine Kollisionen. Daher möchte ich warten, bis die Lösung hinzugefügt wird (meistens, damit ich eine reale Testbedingung habe).

Bisher funktioniert dies gut für meine Bedürfnisse; Ich kann mir vorstellen, dass dies erweitert werden muss, und einige Probleme, die bei einer erweiterten Verwendung auftreten können, waren jedoch schnell zu implementieren und erforderten nur sehr wenig benutzerdefinierten Code.

Falls sich jemand für die Atomversion interessiert, finden Sie hier die Implementierung. Die Leistung wird besser erwartet als die Version mit Mutex- und Bedingungsvariablen.

class semaphore_atomic
{
public:
    void notify() {
        count_.fetch_add(1, std::memory_order_release);
    }

    void wait() {
        while (true) {
            int count = count_.load(std::memory_order_relaxed);
            if (count > 0) {
                if (count_.compare_exchange_weak(count, count-1, std::memory_order_acq_rel, std::memory_order_relaxed)) {
                    break;
                }
            }
        }
    }

    bool try_wait() {
        int count = count_.load(std::memory_order_relaxed);
        if (count > 0) {
            if (count_.compare_exchange_strong(count, count-1, std::memory_order_acq_rel, std::memory_order_relaxed)) {
                return true;
            }
        }
        return false;
    }
private:
    std::atomic_int count_{0};
};