托管 C++ 中期货和承诺的替代方案是什么

Question

使用 /clr 标志编译托管 C++ 代码时，编译器不允许包含。我正在尝试将我的非托管 C++ 代码移植到托管 C++ 环境中。我看到 C# 有替代 Task 和 TaskCompletionSource 来替换期货和承诺，但我没有看到托管 C++ 中提供这些选项。我需要与一些 C++ 非托管库执行互操作，因此我无法完全切换到 C#。我仍然需要一个 C++ 层。如何在托管 C++ 中实现未来/承诺功能？

下面是一个 C++ 中的非托管代码示例，它可以在没有 /clr 标志的情况下进行编译：

int Foo(std::future<int> &fur) {
    int result = 1;
    int value = fut.get();
    // Do something with value

    return result;
}   

int main() {
    int x;
    std::promise<int> p;
    std::future<int> f = p.get_future();
    std::future<int> fut = std::async(Foo, std::ref(f));
    int val = 1;
    p.set_value(val);
    x = fut.get();
}    

我希望能够在 C++/CLI 中执行此操作

Answer 1

更新（这里重新制定了一些早期的 cmets）：

即使我们选择公共语言运行时支持（C++-Cli、CLR），许多标准 C++ 库也可以免费使用。但是其中一些是不可用的，例如被质疑的。

如果我们添加这样的标题，我们会得到以下错误：

'<future> 在使用 /clr 或 /clr:pure 编译时不受支持。 '

这对我们来说意味着此类代码可能会保留在单独的 dll 中，或者我们必须重构我们的代码，或者我们需要上述库的 C# 实现，例如 this one。

回答：

问题本身包含正确答案，因此可以使用以下方法实现未来和素数：

• Task<T> 是一个未来（或返回单元的未来的任务），
• TaskCompletionSource<T> 是一个承诺，

也显示在帖子here 中。这意味着我们可以简单地将 search C# 替换为 future 和 promise，然后将它们转换为 C++-Cli。

在我的回答中，我只展示了如何翻译和使用Task 和内置委托的一些关键点。任务本身很简单：

    #include "stdafx.h"

    using namespace System;
    using namespace System::Threading::Tasks;

    public ref class MyActions
    {
    public:
        MyActions()
        {
            // lambdas are not allowed for managed class so we use built in delegates
            auto t = gcnew Task(gcnew Action<Object^>(task1),this);
        }

    public:
        static void task1(Object^ o)
        {
            // TODO:
            printf("Hello World! [c++-cli] and [win32]");
        }
    };

如您所见，C++-Cli 语法与 c# 非常相似，并且您仍然拥有大部分“旧”C++。

注意：我们仍然应该将类定义和实现分开（myactions.h 和 myactions.cpp）

Answer 2

C++ / CLI 不允许包含任何标准头文件 <mutex>、<future>、<thread> 和 <condition_variable>（顺便说一句，在 VS2017 中你可以使用 <atomic>）。它也不允许使用微软提供的concurrency runtime。

由于您使用的是 C++ / CLI，我认为可移植性不是问题。 我的建议是您使用 Windows API 周围的瘦包装器来滚动您自己的互斥锁、条件变量、未来和承诺。

前段时间我写了一些代码来做这件事。这并不像听起来那么难。

注意：

• 此附加代码并不意味着以任何方式符合标准。
• srwlock 是 std::mutex 的替代品，甚至可以与 std::lock_guard / std::unique_lock。
• srwcondition_variable 是 std::condition_variable 的替代品。
• unique_srwlock 是 std::unique_lock 的替代品（用于 srwcondition_variable)。
• srfuture 和 srpromise 是 std::future 和 std::promise 的替代品。

：

#include <windows.h>

class srwlock
{
    SRWLOCK _lk{};
public:
    void lock()
    {
        AcquireSRWLockExclusive(&_lk);
    }
    void unlock()
    {
        ReleaseSRWLockExclusive(&_lk);
    }
    void lock_shared()
    {
        AcquireSRWLockShared(&_lk);
    }

    void unlock_shared()
    {
        ReleaseSRWLockShared(&_lk);
    }
    SRWLOCK* native_handle()
    {
        return &_lk;
    }
    srwlock() = default;
    srwlock(const srwlock&) = delete;
    srwlock& operator=(const srwlock&) = delete;
    srwlock(srwlock&&) = delete;
    srwlock& operator=(srwlock&&) = delete;
};


template <typename _Lk>
class unique_srwlock
{
    _Lk& _lk;
    friend class srwcondition_variable;
public:
    void lock()
    {
        _lk.lock();
    }
    void unlock()
    {
        _lk.unlock();
    }

    unique_srwlock(_Lk& lk) : _lk(lk)
    {
        _lk.lock();
    };

    ~unique_srwlock()
    {
        _lk.unlock();
    };

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

};

    enum class srcv_status
{
    timeout, no_timeout
};

class srwcondition_variable
{
    CONDITION_VARIABLE _cv{}; 
public:
    void wait(srwlock& lk)
    {
        VERIFY_TRUE(SleepConditionVariableSRW(&_cv, lk.native_handle(), INFINITE, 0));
    }
    void wait(unique_srwlock<srwlock>& lk)
    {
        VERIFY_TRUE(SleepConditionVariableSRW(&_cv, lk._lk.native_handle(), INFINITE, 0));
    }

    srcv_status wait_for(unique_srwlock<srwlock>& lk, const std::chrono::milliseconds& timeout_duration)
    {
        auto val = SleepConditionVariableSRW(&_cv, lk._lk.native_handle(), static_cast<DWORD>(timeout_duration.count()), 0);

        if (val != 0)
        {
            return srcv_status::no_timeout;
        }
        else
        {
            if (GetLastError() == ERROR_TIMEOUT)
            {
                return srcv_status::timeout;
            }
            else
            {
                throw std::runtime_error("wait_for unexpected return value in SleepConditionVariableSRW");
            }
        }
    }

    void notify_one()
    {
        WakeConditionVariable(&_cv);
    }
    void notify_all()
    {
        WakeAllConditionVariable(&_cv);
    }

    srwcondition_variable() = default;
    srwcondition_variable(const srwcondition_variable&) = delete;
    srwcondition_variable& operator=(const srwcondition_variable&) = delete;
    srwcondition_variable(srwcondition_variable&&) = delete;
    srwcondition_variable& operator=(srwcondition_variable&&) = delete;
};



class bad_srfuture : public std::runtime_error
{
public:
    bad_srfuture(const char* msg) : std::runtime_error(msg) {}
};

inline void throw_bad_srfuture(bool isValid)
{
    if (!isValid)
    {
        throw bad_srfuture("no state");
    }
}

#ifdef _DEBUG
#ifndef FUTURE_THROW_ON_FALSE
#define FUTURE_THROW_ON_FALSE(stmt) throw_bad_srfuture(stmt);
#endif
#else
#ifndef FUTURE_THROW_ON_FALSE
#define FUTURE_THROW_ON_FALSE(stmt) __noop
#endif
#endif


enum class srfuture_status
{
    deffered, ready, timeout
};


namespace private_details
{
    template <typename T>
    class future_shared_state
    {
    public:
        void wait() const
        {
            // wait until there is either state or error
            unique_srwlock<srwlock> lk(_cs);
            while (!_state && !_error)
            {
                _available.wait(lk);
            }
        }
        srfuture_status wait_for(const std::chrono::milliseconds& timeout_duration)
        {
            // wait until there is either state or error
            unique_srwlock<srwlock> lk(_cs);
            while (!_state && !_error)
            {
                auto cv_status = _available.wait_for(lk, timeout_duration);
                if (cv_status == srcv_status::timeout)
                {
                    return srfuture_status::timeout;
                }
            }
            return srfuture_status::ready;
        }
        T& get()
        {
            if (_state) return *_state;
            if (_error) std::rethrow_exception(_error);
            throw std::logic_error("no state nor error after wait");
        }
        template <typename U>
        void set_value(U&& value)
        {
            unique_srwlock<srwlock> lk(_cs);
            if (_state.has_value() || _error != nullptr)
            {
                throw bad_srfuture("shared state already set");
            }

            _state.emplace(std::forward<U>(value));
            _available.notify_all();
        }

        void set_exception(std::exception_ptr e) 
        {
            unique_srwlock<srwlock> lk(_cs);
            if (_state.has_value() || _error != nullptr)
            {
                throw bad_srfuture("shared state already set");
            }
            _error = e;
            _available.notify_all();
        }
    private:
        mutable srwlock _cs; // _state protection
        mutable srwcondition_variable _available;
        std::optional<T> _state;
        std::exception_ptr _error;
    };
} // namespace private_details
template <typename T> class srpromise;

template <typename T>
class srfuture {
public:
    srfuture() noexcept = default;
    ~srfuture() = default;
    srfuture(srfuture const& other) = delete;
    srfuture& operator=(srfuture const& other) = delete;
    srfuture& operator=(srfuture&& other) noexcept = default;
    srfuture(srfuture&&) noexcept = default;

    T get() 
    {
        // get is assumed to be called from a single thread.

        // step 1: pass the _shared_state to the current thread waiter (invalidate)
        // (other threads calling get() will result in undefined behaviour as _shared_state will be nullptr
        auto shared_state = std::move(_shared_state);

        FUTURE_THROW_ON_FALSE(shared_state != nullptr);

        // step 2:  safely wait for the shared state to fulfill
        shared_state->wait();

        // shared state is fulfilled and no exception is set.
        // step 3: move / copy the state:
        return std::move(shared_state->get()); // https://stackoverflow.com/questions/14856344/when-should-stdmove-be-used-on-a-function-return-value   
    }

    bool valid() const noexcept 
    { 
        return _shared_state != nullptr; 
    }

    void wait() const 
    {
        // The behavior is undefined if valid() == false before the call to this function.
        FUTURE_THROW_ON_FALSE(valid());
        _shared_state->wait();
    }

    srfuture_status wait_for(const std::chrono::milliseconds& timeout_duration) const
    {
        FUTURE_THROW_ON_FALSE(valid());
        _shared_state->wait_for(timeout_duration);
    }
private:
    std::shared_ptr<private_details::future_shared_state<T>> _shared_state = nullptr;

    friend class srpromise<T>;
    srfuture(const std::shared_ptr<private_details::future_shared_state<T>>& shared_state) : _shared_state(shared_state) {}
    srfuture(std::shared_ptr<private_details::future_shared_state<T>>&& shared_state) : _shared_state(std::move(shared_state)) {}
};

template <typename T>
class srpromise 
{
public:
    srpromise() : _shared_state(std::make_shared<private_details::future_shared_state<T>>()) {}
    srpromise(srpromise&& other) noexcept = default;
    srpromise(const srpromise& other) = delete;
    srpromise& operator=(srpromise&& other) noexcept = default;
    srpromise& operator=(srpromise const& rhs) = delete;
    ~srpromise() = default;

    void swap(srpromise& other) noexcept
    { 
        _shared_state.swap(other._shared_state);
    }

    srfuture<T> get_future() 
    {
        return { _shared_state };
    }

    void set_value(const T& value)
    {
        _shared_state->set_value(value);
    }

    void set_value(T&& value) 
    {
        _shared_state->set_value(std::move(value));         
    }

    void set_exception(std::exception_ptr p) 
    {
        _shared_state->set_exception(std::move(p));
    }
private:
    std::shared_ptr<private_details::future_shared_state<T>> _shared_state = nullptr;
};