concurrent_bounded_queue

[containers.concurrent_bounded_queue]

oneapi::tbb::concurrent_bounded_queue は、複数のスレッドがアイテムのプッシュとポップを同時に行うことができる有界の FIFO (先入れ先出し) データ構造のクラス・テンプレートです。

クラス・テンプレートの概要


// <oneapi/tbb/concurrent_queue.h> ヘッダーで定義 

namespace oneapi { 
    namespace tbb { 

        template <typename T, typename Allocator = cache_aligned_allocator<T>> 
        class concurrent_bounded_queue { 
        public: 
            using value_type = T; 
            using reference = T&; 
            using const_reference = const T&; 
            using pointer = typename std::allocator_traits<Allocator>::pointer; 
            using const_pointer = typename std::allocator_traits<Allocator>::const_pointer; 

            using allocator_type = Allocator; 

            using size_type = <implementation-defined signed integer type>; 
            using difference_type = <implementation-defined signed integer type>; 

            using iterator = <implementation-defined ForwardIterator>; 
            using const_iterator = <implementation-defined constant ForwardIterator>; 

            concurrent_bounded_queue(); 

            explicit concurrent_bounded_queue( const allocator_type& alloc ); 

            template <typename InputIterator> 
            concurrent_bounded_queue( InputIterator first, InputIterator last, 
                                      const allocator_type& alloc = allocator_type() ); 

            concurrent_bounded_queue( std::initializer_list<value_type> init, 
                                                   const allocator_type& alloc = allocator_type() ); 

            concurrent_bounded_queue( const concurrent_bounded_queue& other ); 
            concurrent_bounded_queue( const concurrent_bounded_queue& other, 
                                                   const allocator_type& alloc ); 

            concurrent_bounded_queue( concurrent_bounded_queue&& other ); 
            concurrent_bounded_queue( concurrent_bounded_queue&& other, 
                                                  const allocator_type& alloc ); 

            ~concurrent_bounded_queue(); 

            concurrent_bounded_queue& operator=( const concurrent_bounded_queue& other ); 
            concurrent_bounded_queue& operator=( concurrent_bounded_queue&& other ); 
            concurrent_bounded_queue& operator=( std::initializer_list<value_type> init ); 

            template <typename InputIterator> 
            void assign( InputIterator first, InputIterator last ); 

            void assign( std::initializer_list<value_type> init ); 

            void swap( concurrent_bounded_queue& other ); 

            allocator_type get_allocator() const; 

            void push( const value_type& value ); 
            void push( value_type&& value ); 

            bool try_push( const value_type& value ); 
            bool try_push( value_type&& value ); 

            template <typename...Args> 
            void emplace( Args&&... args ); 

            template <typename...Args> 
            bool try_emplace( Args&&... args ); 

            void pop( value_type& result ); 

            bool try_pop( value_type& result ); 

            void abort(); 

            size_type size() const; 

            bool empty() const; 

            void set_capacity( size_type new_capacity ); 

            void clear(); 

            iterator unsafe_begin(); 
            const_iterator unsafe_begin() const; 
            const_iterator unsafe_cbegin() const; 

            iterator unsafe_end(); 
            const_iterator unsafe_end() const; 
            const_iterator unsafe_cend() const; 
        }; // class concurrent_bounded_queue 

    } // namespace tbb 
} // namespace oneapi

要件:

  • T タイプは、[container.requirements] ISO C++ 標準の Erasable 要件を満たしている必要があります。メンバー関数は、操作タイプに応じてより厳密な要件を課す場合があります。

  • Allocator タイプは、[allocator.requirements] ISO C++ 標準の Allocator 要件を満たしている必要があります。

メンバー関数

非メンバー関数

これらの関数は、oneapi::tbb::concurrent_bounded_queue オブジェクトに対するバイナリー比較およびスワップ操作を提供します。

これらの関数が定義される名前空間は、それぞれの比較操作で使用できるかぎり未指定です。例えば、実装では、同じ内部名前空間でクラスと関数を定義し oneapi::tbb::concurrent_bounded_queue をタイプエイリアスとして定義できます。この場合、非メンバー関数には引数依存のルックアップによってのみ到達できます。

template <typename T, typename Allocator> 
void swap( concurrent_bounded_queue<T, Allocator>& lhs, 
           concurrent_bounded_queue<T, Allocator>& rhs ); 

template <typename T, typename Allocator> 
bool operator==( const concurrent_bounded_queue<T, Allocator>& lhs, 
                 const concurrent_bounded_queue<T, Allocator>& rhs ); 

template <typename T, typename Allocator> 
bool operator!=( const concurrent_bounded_queue<T, Allocator>& lhs, 
                 const concurrent_bounded_queue<T, Allocator>& rhs );

その他