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 세마포어를 작성하기로 결정했습니다 ( 주로 보통 not using semaphore = ...사용하는 semaphore것과 비슷한 이름을 사용합니다 )stringbasic_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-on-multicore를 확인할 수도 있습니다. 이식 가능하고 최적의 세마포어 구현이 있습니다.

이 저장소에는 c ++ 11 스레딩을 보완하는 다른 스레딩 기능도 포함되어 있습니다.

뮤텍스 및 조건 변수로 작업 할 수 있습니다. 뮤텍스에 독점적으로 액세스하고, 계속 진행할 것인지 또는 다른 쪽 끝을 기다려야하는지 확인하십시오. 기다릴 필요가 있으면 조건을 기다립니다. 다른 스레드가 계속할 수 있다고 판단하면 조건을 알립니다.

boost :: thread 라이브러리에는 복사 할 수 있는 짧은 예제 가 있습니다 (C ++ 0x 및 boost thread 라이브러리는 매우 유사 함).

스레드에서 유용한 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_ptr 목록을 갖게됩니다.

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 및 주기적으로 호스트의 업데이트 루틴에서 잠금을 테스트합니다. 잠금 테스트는 weak_ptr이 만료되었는지 확인하고 m_locks 목록에서 만료 된 항목을 제거하는 것 (호스트 업데이트 중에 만 수행)만큼 간단합니다. 목록이 비어 있는지 확인할 수 있습니다. 동시에 클라이언트가 걸려있는 shared_ptr을 재설정하면 자동 잠금 해제가 발생하며 클라이언트가 자동으로 파괴 될 때도 발생합니다.

모든 효과는 클라이언트가 독점 성을 거의 필요로하지 않기 때문에 (일반적으로 추가 및 삭제 전용으로 예약 됨) 대부분의 경우 LockUpdate (false)에 대한 요청, 즉 비 독점은 (! m_exclusiveLock)만큼 성공합니다. 독점 성 요청 인 LockUpdate (true)는 (! m_exclusiveLock) 및 (m_locks.empty ()) 모두에 대해서만 성공합니다.

배타적 잠금과 배타적 잠금을 완화하기 위해 대기열을 추가 할 수는 있지만 지금까지 충돌은 없었으므로 솔루션을 추가 할 때까지 기다릴 것입니다 (대부분 실제 테스트 조건이 있습니다).

지금까지 이것은 내 요구에 잘 작동합니다. 나는 이것을 확장해야 할 필요성과 확장 된 사용으로 인해 발생할 수있는 몇 가지 문제를 상상할 수 있지만, 구현이 빠르고 사용자 정의 코드가 거의 필요하지 않았습니다.

누군가 원자 버전에 관심이있는 경우 구현은 다음과 같습니다. mutex & condition 변수 버전보다 성능이 더 좋습니다.

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