C ++ 0x没有信号量？如何同步线程？

C ++ 0x会没有信号量是真的吗？关于信号量的使用，在堆栈溢出方面已经存在一些问题。我一直使用它们（posix信号量）让一个线程在另一个线程中等待某个事件：

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

  event1.wait();

  ...
}

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

  event1.post();

  ...
}

如果我要用互斥锁来做到这一点：

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

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

  ...
}

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

  doSomethingth1();

  event1.unlock();

  ...
}

问题：这很丑陋，不能保证thread1首先锁定互斥锁（鉴于同一线程应该锁定和解锁互斥锁，因此您也不能在thread0和thread1启动之前锁定event1）。

因此，由于boost也没有信号量，实现以上目标的最简单方法是什么？

您可以通过互斥量和条件变量轻松构建一个：

#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;
    }
};

基于Maxim Yegorushkin的回答，我试图以C ++ 11风格制作示例。

#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;
};

我决定尽我所能以标准样式编写最健壮/通用的C ++ 11信号量（请注意using semaphore = ...，您通常会使用semaphore与stringnot 相似的名称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();
}

根据posix信号量，我将添加

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

而且我更喜欢在方便的抽象级别上使用同步机制，而不是始终使用更多基本运算符来复制粘贴粘贴在一起的版本。

您还可以签出多核cpp11-它具有可移植且最佳的信号量实现。

该存储库还包含其他补充c ++ 11线程的线程功能。

您可以使用互斥和条件变量。您可以使用互斥锁获得独占访问权，请检查您是否要继续还是需要等待另一端。如果您需要等待，则可以在某种情况下等待。当另一个线程确定您可以继续时，它表明情况。

boost :: thread库中有一个简短的示例，您很可能只需复制即可（C ++ 0x和boost线程库非常相似）。

也可以在线程中有用的RAII信号量包装器：

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;
};

多线程应用程序中的用法示例：

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最终将有信号量- std::counting_semaphore<max_count>。

这些将具有（至少）以下方法：

• acquire() （阻止）
• try_acquire() （非阻塞，立即返回）
• try_acquire_for() （非阻塞，需要一段时间）
• try_acquire_until() （非阻塞，需要一段时间才能停止尝试）
• release()

它尚未在cppreference上列出，但是您可以阅读这些CppCon 2019演示幻灯片或观看视频。还有官方建议书P0514R4，但我不确定这是最新版本。

我发现shared_ptr和weak_ptr长了一个列表，做了我需要的工作。我的问题是，我有几个客户想要与主机的内部数据进行交互。通常，主机自行更新数据，但是，如果客户端请求，主机需要停止更新，直到没有客户端访问主机数据为止。同时，客户端可以请求独占访问，这样其他客户端或主机都无法修改该主机数据。

我这样做的方法是创建一个结构：

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

每个客户都有这样的成员：

UpdateLock::ptr m_myLock;

然后主机将具有一个weak_ptr成员用于排他性，以及一个weak_ptrs列表用于非排他锁：

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

有一个启用锁定的功能，以及另一个检查主机是否被锁定的功能：

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

我测试LockUpdate，IsUpdateLocked中的锁，并定期在主机的Update例程中测试锁。测试锁就像检查weak_ptr是否过期，然后从m_locks列表中删除任何过期的内容一样简单（我仅在主机更新期间执行此操作），我可以检查列表是否为空；同时，当客户端重置挂起的shared_ptr时，我会自动解锁，当客户端自动销毁时也会发生这种情况。

总体而言，由于客户端很少需要排他性（通常仅保留用于添加和删除），因此大多数情况下，只要（！m_exclusiveLock），对LockUpdate（false）的请求（即非排他性的）都会成功。仅当（！m_exclusiveLock）和（m_locks.empty（））都成功时，LockUpdate（true）才是排他性的请求。

可以添加一个队列来缓解排他锁和非排他锁之间的冲突，但是到目前为止，我还没有发生冲突，因此我打算等到添加解决方案时再去（大多数情况下，我有一个真实的测试条件）。

到目前为止，这可以很好地满足我的需求；我可以想象需要扩展它，并且可能会因扩展使用而产生一些问题，但是，这实现起来很快，并且只需要很少的自定义代码。

如果有人对原子版本感兴趣，这里是实现。预期性能要优于互斥体和条件变量版本。

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};
};