web-dev-qa-db-ja.com

将来の制限を待たずにstd :: asyncを使用できますか？

高レベル
非同期モードで、終了を待たずに戻り値のない一部の関数を呼び出したいです。 std :: asyncを使用すると、タスクが終了するまで将来のオブジェクトは破壊されません。これにより、私の場合は呼び出しが同期しなくなります。

例

void sendMail(const std::string& address, const std::string& message)
{
    //sending the e-mail which takes some time...
}

myResonseType processRequest(args...)
{
    //Do some processing and valuate the address and the message...

    //Sending the e-mail async
    auto f = std::async(std::launch::async, sendMail, address, message);

    //returning the response ASAP to the client
    return myResponseType;

} //<-- I'm stuck here until the async call finish to allow f to be destructed.
  // gaining no benefit from the async call.

私の質問は

  1. この制限を克服する方法はありますか？
  2. （1）がノーの場合、それらの「ゾンビ」先物を受け取り、それらを待つスレッドを一度実装する必要がありますか？
  3. （1）と（2）はありませんが、他のオプションはありますか？

注：
新しいスレッドの作成には回避したいオーバーヘッドがあるため、thread + detach（@ galop1nで推奨）のオプションは使用しません。 std :: asyncを使用している間（少なくともMSVCで）は、内部スレッドプールを使用しています。

ありがとう

c++multithreadingc++11asynchronousstdasync
37
Roee Gavirel

Futureをグローバルオブジェクトに移動できるため、ローカルfutureのデストラクタが実行されるとき、非同期スレッドが完了するのを待つ必要はありません。

std::vector<std::future<void>> pending_futures;

myResonseType processRequest(args...)
{
    //Do some processing and valuate the address and the message...

    //Sending the e-mail async
    auto f = std::async(std::launch::async, sendMail, address, message);

    // transfer the future's shared state to a longer-lived future
    pending_futures.Push_back(std::move(f));

    //returning the response ASAP to the client
    return myResponseType;

}

N.B.非同期スレッドがprocessRequest関数内のローカル変数を参照する場合、これは安全ではありません。

std::async（少なくともMSVCで）を使用しているときは、内部スレッドプールを使用しています。

これは実際には不適合です。標準では、std::launch::asyncを使用して実行するタスクは新しいスレッドで実行する必要があることを明示的に規定しているため、スレッドローカル変数はタスク間で持続してはなりません。ただし、通常は問題ではありません。

15
Jonathan Wakely

参加を気にしないのであれば、なぜスレッドを開始してデタッチしないのですか？

std::thread{ sendMail, address, message}.detach();

std :: asyncは、返されるstd :: futureのライフタイムにバインドされており、それに代わるものではありません。

Std :: futureを他のスレッドによって読み取られる待機キューに入れるには、コンテナの周りのミューテックスなど、新しいタスクを受け取るプールと同じ安全メカニズムが必要です。

したがって、最良のオプションは、スレッドセーフキューに直接プッシュされたタスクを消費するスレッドプールです。また、特定の実装に依存しません。

呼び出し可能および引数を取るスレッドプール実装の下で、スレッドはキューでポーリングを行います。より良い実装では条件変数（ colir ）を使用する必要があります。

#include <iostream>
#include <queue>
#include <memory>
#include <thread>
#include <mutex>
#include <functional>
#include <string>

struct ThreadPool {
    struct Task {
        virtual void Run() const = 0;
        virtual ~Task() {};
    };   

    template < typename task_, typename... args_ >
    struct RealTask : public Task {
        RealTask( task_&& task, args_&&... args ) : fun_( std::bind( std::forward<task_>(task), std::forward<args_>(args)... ) ) {}
        void Run() const override {
            fun_();
        }
    private:
        decltype( std::bind(std::declval<task_>(), std::declval<args_>()... ) ) fun_;
    };

    template < typename task_, typename... args_ >
    void AddTask( task_&& task, args_&&... args ) {
        auto lock = std::unique_lock<std::mutex>{mtx_};
        using FinalTask = RealTask<task_, args_... >;
        q_.Push( std::unique_ptr<Task>( new FinalTask( std::forward<task_>(task), std::forward<args_>(args)... ) ) );
    }

    ThreadPool() {
        for( auto & t : pool_ )
            t = std::thread( [=] {
                while ( true ) {
                    std::unique_ptr<Task> task;
                    {
                        auto lock = std::unique_lock<std::mutex>{mtx_};
                        if ( q_.empty() && stop_ ) 
                            break;
                        if ( q_.empty() )
                            continue;
                        task = std::move(q_.front());
                        q_.pop();
                    }
                    if (task)
                        task->Run();
                }
            } );
    }
    ~ThreadPool() {
        {
            auto lock = std::unique_lock<std::mutex>{mtx_};
            stop_ = true;
        }
        for( auto & t : pool_ )
            t.join();
    }
private:
    std::queue<std::unique_ptr<Task>> q_;
    std::thread pool_[8]; 
    std::mutex mtx_;
    volatile bool stop_ {};
};

void foo( int a, int b ) {
    std::cout << a << "." << b;
}
void bar( std::string const & s) {
    std::cout << s;
}

int main() {
    ThreadPool pool;
    for( int i{}; i!=42; ++i ) {
        pool.AddTask( foo, 3, 14 );    
        pool.AddTask( bar, " - " );    
    }
}
7
galop1n

Futureをglobal objectに移動する（および未使用のfutureの削除を手動で管理する）のではなく、実際に非同期で呼び出される関数のlocal scopeに移動することができます。

「非同期機能に独自の未来を持たせましょう」といわれています。

私は私のために働くこのテンプレートラッパーを考え出しました（Windowsでテスト済み）：

#include <future>

template<class Function, class... Args>
void async_wrapper(Function&& f, Args&&... args, std::future<void>& future,
                   std::future<void>&& is_valid, std::promise<void>&& is_moved) {
    is_valid.wait(); // Wait until the return value of std::async is written to "future"
    auto our_future = std::move(future); // Move "future" to a local variable
    is_moved.set_value(); // Only now we can leave void_async in the main thread

    // This is also used by std::async so that member function pointers work transparently
    auto functor = std::bind(f, std::forward<Args>(args)...);
    functor();
}

template<class Function, class... Args> // This is what you call instead of std::async
void void_async(Function&& f, Args&&... args) {
    std::future<void> future; // This is for std::async return value
    // This is for our synchronization of moving "future" between threads
    std::promise<void> valid;
    std::promise<void> is_moved;
    auto valid_future = valid.get_future();
    auto moved_future = is_moved.get_future();

    // Here we pass "future" as a reference, so that async_wrapper
    // can later work with std::async's return value
    future = std::async(
        async_wrapper<Function, Args...>,
        std::forward<Function>(f), std::forward<Args>(args)...,
        std::ref(future), std::move(valid_future), std::move(is_moved)
    );
    valid.set_value(); // Unblock async_wrapper waiting for "future" to become valid
    moved_future.wait(); // Wait for "future" to actually be moved
}

移動したフューチャーのデストラクタがasync_wrapperを離れるまでブロックするだろうと思ったので、それが動作することに少し驚いています。 async_wrapperが戻るのを待つ必要がありますが、それはまさにその関数内で待っています。論理的には、デッドロックになるはずですが、そうではありません。

また、async_wrapperの最後に行を追加して、将来のオブジェクトを手動で空にしようとしました。

our_future = std::future<void>();

これもブロックしません。

3
Jan Noha

私は何をしているのか分かりませんが、これはうまくいくようです：

_// :( http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3451.pdf
template<typename T>
void noget(T&& in)
{
    static std::mutex vmut;
    static std::vector<T> vec;
    static std::thread getter;
    static std::mutex single_getter;
    if (single_getter.try_lock())
    {
        getter = std::thread([&]()->void
        {
            size_t size;
            for(;;)
            {
                do
                {
                    vmut.lock();
                    size=vec.size();
                    if(size>0)
                    {
                        T target=std::move(vec[size-1]);
                        vec.pop_back();
                        vmut.unlock();
                        // cerr << "getting!" << endl;
                        target.get();
                    }
                    else
                    {
                        vmut.unlock();
                    }
                }while(size>0);
                // ¯\_(ツ)_/¯
                std::this_thread::sleep_for(std::chrono::milliseconds(100));
            }
        });
        getter.detach();
    }
    vmut.lock();
    vec.Push_back(std::move(in));
    vmut.unlock();
}
_

投げる未来のタイプごとに専用のゲッタースレッドを作成します（たとえば、未来と未来を与えると2つのスレッドがあります。100xの未来を与えると、まだ2つのスレッドしかありません）。そして、あなたが対処したくない未来があるとき、ただnotget(fut);を行う-noget(std::async([]()->void{...}));もうまく機能し、ブロックはないようだ。警告、do not noget（）を使用した後、futureから値を取得しようとします。それはおそらくUBであり、トラブルを求めています。

0
hanshenrik