C ++ 0x không có semaphores? Làm thế nào để đồng bộ hóa chủ đề?

Có đúng là C ++ 0x sẽ đến mà không có semaphores? Đã có một số câu hỏi về Stack Overflow liên quan đến việc sử dụng semaphores. Tôi sử dụng chúng (semixhores) mọi lúc để một chủ đề chờ một sự kiện nào đó trong một chủ đề khác:

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

  event1.wait();

  ...
}

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

  event1.post();

  ...
}

Nếu tôi sẽ làm điều đó với một mutex:

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

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

  ...
}

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

  doSomethingth1();

  event1.unlock();

  ...
}

Vấn đề: Thật xấu xí và không đảm bảo rằng thread1 sẽ khóa mutex trước (Do cùng một luồng nên khóa và mở khóa một mutex, bạn cũng không thể khóa event1 trước khi thread0 và thread1 bắt đầu).

Vì vậy, boost cũng không có semaphores, cách đơn giản nhất để đạt được những điều trên là gì?

Bạn có thể dễ dàng xây dựng một từ một mutex và một biến điều kiện:

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

Dựa trên câu trả lời của Maxim Yegorushkin , tôi đã cố gắng làm ví dụ theo kiểu 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;
};

Tôi đã quyết định viết semaphore C ++ 11 mạnh mẽ / chung chung nhất có thể, theo kiểu tiêu chuẩn nhất có thể (lưu ý using semaphore = ..., thông thường bạn sẽ chỉ sử dụng tên semaphoretương tự như bình thường stringkhông sử dụng 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();
}

phù hợp với semaphores, tôi sẽ thêm

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

Và tôi thích sử dụng một cơ chế đồng bộ hóa ở mức độ trừu tượng thuận tiện, thay vì luôn luôn sao chép việc dán một phiên bản được ghép với nhau bằng các toán tử cơ bản hơn.

Bạn cũng có thể kiểm tra cpp11-on-multicore - nó có triển khai semaphore di động và tối ưu.

Kho lưu trữ cũng chứa các tính năng phân luồng khác bổ sung cho phân luồng c ++ 11.

Bạn có thể làm việc với các biến mutex và điều kiện. Bạn có quyền truy cập độc quyền với mutex, kiểm tra xem bạn muốn tiếp tục hay cần đợi đến đầu kia. Nếu bạn cần chờ đợi, bạn chờ trong một điều kiện. Khi luồng khác xác định rằng bạn có thể tiếp tục, nó báo hiệu điều kiện.

Có một ví dụ ngắn trong thư viện boost :: thread mà bạn hầu như có thể chỉ cần sao chép (C ++ 0x và boost lib lib rất giống nhau).

Cũng có thể là trình bao bọc semaphore RAII hữu ích trong các chủ đề:

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

Ví dụ sử dụng trong ứng dụng đa luồng:

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 cuối cùng sẽ có semaphores - std::counting_semaphore<max_count> .

Chúng sẽ có (ít nhất) các phương thức sau:

• acquire() (chặn)
• try_acquire() (không chặn, trả về ngay lập tức)
• try_acquire_for() (không chặn, mất một khoảng thời gian)
• try_acquire_until() (không chặn, mất một thời gian để ngừng cố gắng)
• release()

Điều này chưa được liệt kê trên cppreference, nhưng bạn có thể đọc các slide thuyết trình CppCon 2019 này hoặc xem video . Cũng có đề xuất chính thức P0514R4 , nhưng tôi không chắc đó là phiên bản cập nhật nhất.

Tôi tìm thấy shared_ptr và yếu_ptr, một danh sách dài, đã thực hiện công việc tôi cần. Vấn đề của tôi là, tôi đã có một số khách hàng muốn tương tác với dữ liệu nội bộ của máy chủ lưu trữ. Thông thường, máy chủ tự cập nhật dữ liệu, tuy nhiên, nếu máy khách yêu cầu, máy chủ cần dừng cập nhật cho đến khi không có máy khách nào truy cập dữ liệu máy chủ. Đồng thời, một khách hàng có thể yêu cầu quyền truy cập độc quyền, để không có khách hàng nào khác, cũng như máy chủ lưu trữ có thể sửa đổi dữ liệu máy chủ đó.

Làm thế nào tôi làm điều này là, tôi đã tạo ra một cấu trúc:

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

Mỗi khách hàng sẽ có một thành viên như vậy:

UpdateLock::ptr m_myLock;

Sau đó, máy chủ lưu trữ sẽ có một thành viên yếu_ptr để độc quyền và một danh sách các yếu tố_ptrs cho các khóa không độc quyền:

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

Có một chức năng để cho phép khóa và một chức năng khác để kiểm tra xem máy chủ có bị khóa hay không:

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

Tôi kiểm tra các khóa trong LockUpdate, IsUpdateLocked và định kỳ trong thói quen Cập nhật của máy chủ. Việc kiểm tra khóa cũng đơn giản như kiểm tra xem điểm yếu đã hết hạn và xóa bất kỳ khóa nào đã hết hạn khỏi danh sách m_locks (tôi chỉ thực hiện việc này trong quá trình cập nhật máy chủ), tôi có thể kiểm tra xem danh sách có trống không; đồng thời, tôi nhận được mở khóa tự động khi máy khách đặt lại shared_ptr mà chúng đang treo, điều này cũng xảy ra khi máy khách bị hủy tự động.

Hiệu quả trên tất cả là, vì khách hàng hiếm khi cần độc quyền (thường chỉ dành cho bổ sung và xóa), nên phần lớn thời gian yêu cầu LockUpdate (sai), nghĩa là không độc quyền, thành công miễn là (! M_exinatingLock). Và LockUpdate (đúng), yêu cầu độc quyền, chỉ thành công khi cả (! M_exinatingLock) và (m_locks.empty ()).

Một hàng đợi có thể được thêm vào để giảm thiểu giữa các khóa độc quyền và không độc quyền, tuy nhiên, cho đến nay tôi không có va chạm nào, vì vậy tôi dự định sẽ đợi cho đến khi điều đó xảy ra để thêm giải pháp (chủ yếu là tôi có điều kiện thử nghiệm trong thế giới thực).

Cho đến nay điều này đang hoạt động tốt cho nhu cầu của tôi; Tôi có thể tưởng tượng sự cần thiết phải mở rộng điều này và một số vấn đề có thể phát sinh khi sử dụng mở rộng, tuy nhiên, việc này được thực hiện nhanh chóng và yêu cầu rất ít mã tùy chỉnh.

Trong trường hợp ai đó quan tâm đến phiên bản nguyên tử, đây là cách thực hiện. Hiệu suất được mong đợi tốt hơn so với phiên bản biến đổi điều kiện & điều kiện.

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