C++11 の同期

インテル® TBB ライブラリーは、条件変数とスコープロックで C++11 インターフェイスの一部を変更して実装しています。主な違いは次のとおりです。

• C++11 <chrono> インターフェイスの代わりに tbb::tick_count インターフェイスを使用します。

• C++11 std::system_error の代わりに std::runtime_error をスローします。

• constexpr や explicit 演算子のように C++11 言語サポートが必要な機能を省略または変更しています。

• std::mutex の C++11 仕様の呼び出しは必ず tbb::mutex とともに実装します。

• notify_all_at_thread_exit() はサポートされていません。

メンバーの詳細な説明は、C++11 標準規格を参照してください。

「std 名前空間」セクションで説明されているように、ライブラリーは、tbb 名前空間ではなく std 名前空間に C++11 インターフェイスを定義します。

ヘッダー

#include "tbb/compat/condition_variable"

メンバー

namespace std {
        struct defer_lock_t { }; 
        struct try_to_lock_t { }; 
        struct adopt_lock_t { }; 
        const defer_lock_t defer_lock = {};
        const try_to_lock_t try_to_lock = {};
        const adopt_lock_t adopt_lock = {};
     
        template<typename M>
        class lock_guard {
        public:
            typedef M mutex_type;
            explicit lock_guard(mutex_type& m);
            lock_guard(mutex_type& m, adopt_lock_t);
            ~lock_guard();
        };
     
        template<typename M>
        class unique_lock: no_copy {
        public:
            typedef M mutex_type;
     
            unique_lock();
            explicit unique_lock(mutex_type& m);
            unique_lock(mutex_type& m, defer_lock_t);
            unique_lock(mutex_type& m, try_to_lock_t));
            unique_lock(mutex_type& m, adopt_lock_t);
            unique_lock(mutex_type& m, const tick_count::interval_t &i);
            ~unique_lock();
     
            void lock();
     
            bool try_lock();
            bool try_lock_for( const tick_count::interval_t &i );
     
            void unlock();
     
            void swap(unique_lock& u);
     
            mutex_type* release();
     
            bool owns_lock() const;
            operator bool() const;
            mutex_type* mutex() const;
        };
     
        template<typename M>
        void swap(unique_lock<M>& x, unique_lock<M>& y);
     
        enum cv_status {no_timeout, timeout};
     
        class condition_variable : no_copy {
        public:
            condition_variable();
            ~condition_variable();
     
            void notify_one();
            void notify_all();
     
            void wait(unique_lock<mutex>& lock);
     
            template <class Predicate>
            void wait(unique_lock<mutex>& lock, Predicate pred);
     
            cv_status wait_for(unique_lock<mutex>& lock, 
                               const tick_count::interval_t& i);
     
            template<typename Predicate>
            bool wait_for(unique_lock<mutex>& lock, 
                          const tick_count::interval_t &i, 
                          Predicate pred);
     
            typedef implementation-defined native_handle_type;
            native_handle_type native_handle();
        };
    } // std 名前空間