シグナルとは何ですか？

struct Button { boost::signals2::signal<void()> OnClick; }; 

 void ClickHandler() { cout << “Button clicked” << endl; } // ... boost::signals2::connection c = button->OnClick.connect(&ClickHandler); // ... c.disconnect(); 

 struct Button { boost::signals2::signal<void()> OnClick; private: void MouseDownHandler() { OnClick(); } }; 

問題について

1. アトミックに信号に接続してバインドされた状態を取得する方法はありません
2. 信号からのノンブロッキング切断
3. 非同期ハンドラーを無効にしても、すでにスレッドキューにある呼び出しはキャンセルされません。

• StorageManager-フラッシュドライブ、DVD、およびユーザーがコンソールに挿入したその他のメディアに応答するクラス
• MediaScanner-これらの各デバイスでメディアファイルを検索するクラス
• MediaUiModel-これらのメディアファイルを架空のModel-View-anythingフレームワークで表示するためのモデル

アトミックに信号に接続してバインドされた状態を取得する方法はありません

 class StorageManager { public: std::vector<StoragePtr> GetStorages() const; boost::signals2::signal<void(const StoragePtr&)> OnStorageAdded; // ... }; 

 storageManager->OnStorageAdded.connect(&StorageHandler); //      ,     for (auto&& storage : storageManager->GetStorages()) StorageHandler(storage); 

 for (auto&& storage : storageManager->GetStorages()) StorageHandler(storage); //        ,      storageManager->OnStorageAdded.connect(&StorageHandler); 

共通の解決策

 class StorageManager { mutable std::recursive_mutex _mutex; std::vector<StoragePtr> _storages; public: StorageManager() { /* ... */ } boost::signals2::signal<void(const StoragePtr&)> OnStorageAdded; std::recursive_mutex& GetMutex() const { return _mutex; } std::vector<StoragePtr> GetStorages() const { std::lock_guard<std::recursive_mutex> l(_mutex); return _storages; } private: void ReportNewStorage(const StoragePtr& storage) { std::lock_guard<std::recursive_mutex> l(_mutex); _storages.push_back(storage); OnStorageAdded(storage); } }; // ... { std::lock_guard<std::recursive_mutex> l(storageManager->GetMutex()); storageManager->OnStorageAdded.connect(&StorageHandler); for (auto&& storage : storageManager->GetStorages()) StorageHandler(storage); } 

• std :: recursive_mutexの代わりにstd :: mutexを使用する場合、 GetStoragesメソッド内でそれをキャプチャする機能が失われ、 StorageManagerクラスが非スレッドセーフになります。
• StorageManagerのスレッドセーフを失うことなく、 GetStorages内のコレクションのコピーを取り除くことはできません。
• タイプstd :: vector <StoragePtr> outsideを表示する必要がありますが、実際にはこれらは実装の詳細にすぎません
• 信号に接続して現在の状態を受信するためのかなり大量のコード。この場合、これは異なる信号に対してほぼ同じです。

より良い方法は？

 template < typename Signature > class signal { using populator_type = std::function<void(const std::function<Signature>&)>; mutable std::mutex _mutex; std::list<std::function<Signature> > _handlers; populator_type _populator; public: signal(populator_type populator) : _populator(std::move(populator)) { } std::mutex& get_mutex() const { return _mutex; } signal_connection connect(std::function<Signature> handler) { std::lock_guard<std::mutex> l(_mutex); _populator(handler); //        _handlers.push_back(std::move(handler)); return signal_connection([&]() { /*    _handlers */ } ); } // ... }; 

 class StorageManager { std::vector<StoragePtr> _storages; public: StorageManager() : _storages([&](const std::function<void(const StoragePtr&)>& h) { for (auto&& s : _storages) h(s); }) { /* ... */ } signal<void(const StoragePtr&)> OnStorageAdded; private: void ReportNewStorage(const StoragePtr& storage) { //      ,     , //          _storages std::lock_guard<std::mutex> l(OnStorageAdded.get_mutex()); _storages.push_back(storage); OnStorageAdded(storage); } }; 

 StorageManager() : _storages([&](auto&& h) { for (auto&& s : _storages) h(s); }) { } 

 storageManager->OnStorageAdded.connect(&StorageHandler); 

信号からのノンブロッキング切断

 class MediaScanner { private: boost::signals2::connection _connection; public: MediaScanner(const StorageManagerPtr& storageManager) { _connection = storageManager->OnStorageAdded.connect([&](const StoragePtr& s) { this->StorageHandler(s); }); } ~MediaScanner() { _connection.disconnect(); //        ,  . //   ,        MediaScanner. } private: void StorageHandler(const StoragePtr& storage) { /*  -  */ } }; 

Qtのソリューション

 mediaScanner->deleteLater(); 

Boostのソリューション:: Signals2

 class MediaScanner { public: static std::shared_ptr<MediaScanner> Create(const StorageManagerPtr& storageManager) { std::lock_guard<std::recursive_mutex> l(storageManager->GetMutex()); MediaScannerPtr result(new MediaScanner); boost::signals2::signal<void(const StoragePtr&)>::slot_type slot(bind(&MediaScanner::StorageHandler, result.get(), _1)); slot.track_foreign(result); storageManager->OnStorageAdded.connect(slot); for (auto&& storage : storageManager->GetStorages()) result->StorageHandler(storage); return result; } private: MediaScanner() //  ! { /*  ,    */ } void StorageHandler(const StoragePtr& storage); { /*  -  */ } }; 

• ああ、毎回コピーするたくさんのコード
• MediaScannerの初期化は 2つの部分に分かれています。Createメソッドでシグナルをサブスクライブすること、およびコンストラクターで他のすべてをサブスクライブすることです。
• MediaScannerを保存するにはshared_ptrを使用する必要があります
• MediaScannerへの最後の外部リンクをリリースしたときにMediaScannerが削除されたかどうかはわかりません。 MediaScannerのリリース後に再利用したい限られたリソースを使用する場合、これは問題になる可能性があります。

より良い方法は？

• life_token-ハンドラーの存続期間を制御し、ハンドラーを「死んでいる」とマークし、必要に応じて実行の終了を待つことができます
• life_token ::チェッカー -ハンドラーの隣のシグナル内に格納され、そのlife_tokenを参照します
• life_token :: checker :: execution_guard-ハンドラーの実行中にスタック上に作成され、対応するlife_tokenをブロックし、ハンドラーが早く「死んだ」かどうかを確認できます

 class signal_connection { life_token _token; std::function<void()> _eraseHandlerFunc; public: signal_connection(life_token token, std::function<void()> eraseHandlerFunc) : _token(token), _eraseHandlerFunc(eraseHandlerFunc) { } ~signal_connection(); { disconnect(); } void disconnect() { if (_token.released()) return; _token.release(); //   ,     (. . ) _eraseHandler(); //   -,      } }; 

 template < typename Signature > class signal { using populator_type = std::function<void(const std::function<Signature>&)>; struct handler { std::function<Signature> handler_func; life_token::checker life_checker; }; mutable std::mutex _mutex; std::list<handler> _handlers; populator_type _populator; public: // ... signal_connection connect(std::function<Signature> handler) { std::lock_guard<std::mutex> l(_mutex); life_token token; _populator(handler); _handlers.push_back(Handler{std::move(handler), life_token::checker(token)}); return signal_connection(token, [&]() { /*    _handlers */ } ); } template < typename... Args > void operator() (Args&&... args) const { for (auto&& handler : _handlers) { life_token::checker::execution_guard g(handler.life_checker); if (g.is_alive()) handler.handler_func(forward<Args>(args)...); } } }; 

 class life_token { struct impl { std::mutex mutex; bool alive = true; }; std::shared_ptr<impl> _impl; public: life_token() : _impl(std::make_shared<impl>()) { } ~life_token() { release(); } bool released() const { return !_impl; } void release() { if (released()) return; std::lock_guard<std::mutex> l(_impl->mutex); _impl->alive = false; _impl.reset(); } class checker { shared_ptr<impl> _impl; public: checker(const life_token& t) : _impl(t._impl) { } class execution_guard { shared_ptr<Impl> _impl; public: execution_guard(const checker& c) : _impl(c._impl) { _impl->mutex.lock(); } ~execution_guard() { _impl->mutex.unlock(); } bool is_alive() const { return _impl->alive; } }; }; }; 

 class MediaScanner { private: signals_connection _connection; public: MediaScanner(const StorageManagerPtr& storageManager) { _connection = storageManager->OnStorageAdded.connect([&](const StoragePtr& s) { this->StorageHandler(s); }); } ~MediaScanner() { _connection.disconnect(); } private: void StorageHandler(const StoragePtr& storage) { /*  -  */ } }; 

非同期ハンドラーを無効にしても、すでにスレッドキューにある呼び出しはキャンセルされません。

 signal<void(const MediaPtr&)> OnMediaFound; 

• モデルはUIライブラリのオブジェクトであるため、モデルに対するすべてのアクションはUIストリームから実行する必要があります。
• 多くの場合、UIライブラリは独自の所有権階層を使用するため、 shared_ptrを使用してモデルを保存することはできません。 したがって、 track / track_foreignによるフォーカスはここでは機能しませんが、これは今では主なことではないので、すべてが正常であるふりをしましょう

 class MediaUiModel : public UiModel<MediaUiModelRow> { private: boost::io_service& _uiThread; boost::signals2::connection _connection; public: MediaUiModel(boost::io_service& uiThread, const MediaScanner& scanner) : _uiThread(uiThread) { std::lock_guard<std::recursive_mutex> l(scanner.GetMutex()); scanner.OnMediaFound.connect([&](const MediaPtr& m) { this->MediaHandler(m); }); for (auto&& m : scanner.GetMedia()) AppendRow(MediaUiModelRow(m)) } ~MediaUiModel() { _connection.disconnect(); } private: //      MediaScanner',        UI. void MediaHandler(const MediaPtr& m) { _uiThread.post([&]() { this->AppendRow(MediaUiModelRow(m)); }); } }; 

Qtのソリューション

Boostのソリューション:: Signals2

 template < typename Signature_ > class AsyncToUiHandlerWrapper { private: boost::io_service& _uiThread; std::function<Signature_> _realHandler; bool _released; mutable std::mutex _mutex; public: AsyncToUiHandlerWrapper(boost::io_service& uiThread, std::function<Signature_> realHandler) : _uiThread(uiThread), _realHandler(realHandler), _released(false) { } void Release() { std::lock_guard<std::mutex> l(_mutex); _released = true; } template < typename... Args_ > static void AsyncHandler(const std::weak_ptr<AsyncToUiHandlerWrapper>& selfWeak, Args_&&... args) { auto self = selfWeak.lock(); std::lock_guard<std::mutex> l(self->_mutex); if (!self->_released) // AsyncToUiHandlerWrapper   ,  _uiThread       self->_uiThread.post(std::bind(&AsyncToUiHandlerWrapper::UiThreadHandler<Args_&...>, selfWeak, std::forward<Args_>(args)...))); } private: template < typename... Args_ > static void UiThreadHandler(const std::weak_ptr<AsyncToUiHandlerWrapper>& selfWeak, Args_&&... args) { auto self = selfWeak.lock(); if (!self) return; if (!self->_released) // AsyncToUiHandlerWrapper   , , ,  _realHandler,   self->_realHandler(std::forward<Args_>(args)...); } }; class MediaUiModel : public UiModel<MediaUiModelRow> { private: using AsyncMediaHandler = AsyncToUiHandlerWrapper<void(const MediaPtr&)>; private: std::shared_ptr<AsyncMediaHandler> _asyncHandler; public: MediaUiModel(boost::io_service& uiThread, const MediaScanner& scanner) { try { _asyncHandler = std::make_shared<AsyncMediaHandler>(std::ref(uiThread), [&](const MediaPtr& m) { this->AppendRow(MediaUiModelRow(m)); }); std::lock_guard<std::recursive_mutex> l(scanner.GetMutex()); boost::signals2::signal<void(const MediaPtr&)>::slot_type slot(std::bind(&AsyncMediaHandler::AsyncHandler<const MediaPtr&>, std::weak_ptr<AsyncMediaHandler>(_asyncHandler), std::placeholders::_1)); slot.track_foreign(_asyncHandler); scanner.OnMediaFound.connect(slot); for (auto&& m : scanner.GetMedia()) AppendRow(MediaUiModelRow(m)); } catch (...) { Destroy(); throw; } } ~MediaUiModel() { Destroy(); } private: void Destroy() { if (_asyncHandler) _asyncHandler->Release(); //      MediaUiModel   ,       _asyncHandler.reset(); } }; 

より良い方法は？

 struct task_executor { virtual ~task_executor() { } virtual void add_task(const std::function<void()>& task) = 0; }; 

 signal_connection connect(const std::shared_ptr<task_executor>& worker, std::function<Signature> handler); 

 class MediaUiModel : public UiModel<MediaUiModelRow> { private: signal_connection _connection; public: MediaUiModel(const std::shared_ptr<task_executor>& uiThread, const MediaScanner& scanner) { _connection = scanner.OnMediaFound.connect(uiThread, [&](const MediaPtr& m) { this->AppendRow(MediaUiModelRow(m)); }); } ~MediaUiModel() { _connection.reset(); } }; 

まとめると

1. ポピュレーターにより、信号に接続しながら現在の状態を簡単に取得できます
2. 切断ブロックメソッドを使用すると、オブジェクトを独自のデストラクタでサブスクライブ解除できます。
3. 前の項目が非同期ハンドラーに当てはまるように、 切断は、ストリームキューに既に存在する呼び出しを「無関係」としてマークする必要もあります。

すぐに使える

ミニFAQ

 class mutex { private: std::timed_mutex _m; public: void lock() { if (_m.try_lock()) return; while (!_m.try_lock_for(std::chrono::seconds(10))) Logger::Warning() << "Could not lock mutex " << (void*)this << " for a long time:\n" << get_backtrace_string(); } // ... };