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

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

  event1.wait();

  ...
}

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

  event1.post();

  ...
}

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

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

  ...
}

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

  doSomethingth1();

  event1.unlock();

  ...
}

#1 楼

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

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

#2 楼

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

#3 楼

我决定尽我所能以标准的样式编写最健壮/通用的C ++ 11信号量（请注意using semaphore = ...，您通常使用的名称semaphore类似于通常使用string而不是basic_string）： br />

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

#4 楼

根据posix信号量，我会添加

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

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

#5 楼

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

存储库还包含其他补充c ++ 11线程的线程工具。

#6 楼

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

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

#7 楼

C ++ 20最终有信号量-std::counting_semaphore<max_count>。
这些（至少）具有以下方法：


acquire()（阻止）

try_acquire()（非阻塞，立即返回）

try_acquire_for()（非阻塞，需要一定时间）

try_acquire_until()（非阻塞，需要一段时间才能停止尝试）
release()

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

#8 楼

也可以在线程中有用的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();

#9 楼

我发现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;

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

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

可以添加一个队列来缓解排他性和非排他性锁，但是到目前为止，我还没有碰撞，因此我打算等到碰巧添加解决方案时（主要是因为我有一个真实的测试条件）。

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

#10 楼

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

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