Vadeli işlemler vs Sözler

SORU

27 EYLÜL 2012, PERŞEMBE

Vadeli işlemler vs Sözler

Bir gelecek ve söz arasındaki fark ile kendimi canım.

Belli ki, farklı yöntemler falan var, ama ne gerçek kullanım durumda?

Mi?:

bazı zaman uyumsuz görev idare ediyorum, değerini almak için gelecek kullanırım "gelecekte"
zaman uyumsuz görev yapıyorum, kullanıcı sözümü bir geleceği olsun izin vermek için dönüş türü olarak söz kullanıyorum

CEVAP

27 EYLÜL 2012, PERŞEMBE

Gelecek Vaat zaman uyumsuz bir işlem iki ayrı yüzü vardır.

std::promise "yapımcı/yazar" zaman uyumsuz işlem tarafından kullanılır

std::future "tüketici/okuyucu" zaman uyumsuz işlem tarafından kullanılır

Bunlar ikiye ayrılır nedeni "arabirimler". ayrı ^strong>gizlemek"/"işlevsellik "tüketici/okuyucu". yazma seti

auto promise = std::promise<std::string>();

auto producer = std::thread([&]
{
    promise.set_value("Hello World");
});

auto future = promise.get_future();

auto consumer = std::thread([&]
{
    std::cout << future.get();
});

producer.join();
consumer.join();

(Tamamlanmamış) std uygulamaya yol:zaman uyumsuz kullanarak std::söz olabilir:

template<typename F>
auto async(F&& func) -> std::future<decltype(func())>
{
    typedef decltype(func()) result_type;

    auto promise = std::promise<result_type>();
    auto future  = promise.get_future();

    std::thread(std::bind([=](std::promise<result_type>& promise)
    {
        try
        {
            promise.set_value(func()); // Note: Will not work with std::promise<void>. Needs some meta-template programming which is out of scope for this question.
        }
        catch(...)
        {
            promise.set_exception(std::current_exception());
        }
    }, std::move(promise))).detach();

    return std::move(future);
}

Daha kapsamlı ve muhtemelen daha hızlı olan bir yardımcı (yani yukarıda ne yaptığımızı temelde yok) std::promise etrafta aşağıdaki yapabilirsiniz hangi std::packaged_task kullanarak:

template<typename F>
auto async(F&& func) -> std::future<decltype(func())>
{
    auto task   = std::packaged_task<decltype(func())()>(std::forward<F>(func));
    auto future = task.get_future();

    std::thread(std::move(task)).detach();

    return std::move(future);
}

Bunu Paylaş: