Class template queue . Boost , The Boost C++ Libraries BoostBook Documentation Subset , Reference

Class template queue

boost::lockfree::queue

Synopsis

// In header: <boost/lockfree/queue.hpp>
template<typename T, typename A0, typename A1, typename A2> 
class queue {
public:
  // member classes/structs/unions
  template<typename T, typename... Options> 
  struct implementation_defined {
    // types
    typedef node_allocator allocator;
    typedef std::size_t    size_type;
  };
  // construct/copy/destruct
  queue(void);
  template<typename U> 
    explicit queue(typename node_allocator::template rebind< U >::other const &);
  explicit queue(allocator const &);
  explicit queue(size_type);
  template<typename U> 
    queue(size_type, 
          typename node_allocator::template rebind< U >::other const &);
  ~queue(void);
  // private member functions
   BOOST_STATIC_ASSERT((boost::has_trivial_destructor< T >::value));
   BOOST_STATIC_ASSERT((boost::has_trivial_assign< T >::value));
  struct BOOST_ALIGNMENT(BOOST_LOCKFREE_CACHELINE_BYTES);
  void initialize(void);
   BOOST_DELETED_FUNCTION(queue(queue const &));
  bool is_lock_free(void) const;
  void reserve(size_type);
  void reserve_unsafe(size_type);
  bool empty(void) const;
  bool push(T const &);
  bool bounded_push(T const &);
  template<bool Bounded> bool do_push(T const &);
  // public member functions
  bool unsynchronized_push(T const &);
  bool pop(T &);
  template<typename U> bool pop(U &);
  bool unsynchronized_pop(T &);
  template<typename U> bool unsynchronized_pop(U &);
  template<typename Functor> bool consume_one(Functor &);
  template<typename Functor> bool consume_one(Functor const &);
  template<typename Functor> size_t consume_all(Functor &);
  template<typename Functor> size_t consume_all(Functor const &);
};

Description

Класс очереди обеспечивает многописательную / многочитательную очередь, толкание и выскакивание не запираются, конструкцию / разрушение необходимо синхронизировать. Он использует свободный список для управления памятью, освобожденные узлы выталкиваются в свободный список и не возвращаются в ОС до того, как очередь будет уничтожена.

Политика:

boost::lockfree::fixed_size, по умолчанию до<boost::lockfree::fixed_sized<false>>
Можно использовать для полного отключения динамических выделений памяти во время толчка, чтобы обеспечить свободное поведение.
Если структура данных сконфигурирована как фиксированного размера, внутренние узлы хранятся внутри массива, и они рассматриваются путем индексации массива. Это ограничивает возможный размер очереди количеством элементов, которые могут быть адресованы по типу индекса (обычно 2**16-2), но на платформах, которые не имеют двухширотных инструкций сравнения и обмена, это лучший способ добиться свободы блокировки.
повышение::lockfree:: емкость, факультативно
Если этот шаблонный аргумент передается опциям, размер очереди устанавливается во время компиляции.
Этот вариант подразумевает<fixed_sized<true>>
boost::lockfree::allocator, defaults to<boost::lockfree::allocator<std::allocator<void>>>
Указывает распределитель, который используется для внутреннего свободного списка

Требования:

У Т должен быть конструктор копий
Т должен иметь тривиального оператора назначения
Т должен иметь тривиальный деструктор

`queue` public construct/copy/destruct

```
queue(void);
```
Очередь строительства.

template<typenameU>
 explicitqueue(typenamenode_allocator::templaterebind<U>::otherconst&alloc);

<
```
explicitqueue(allocatorconst&alloc);
```
>
```
explicitqueue(size_typen);
```
Построить очередь, выделить n узлов для свободного списка.

template<typenameU>
 queue(size_typen,
       typenamenode_allocator::templaterebind<U>::otherconst&alloc);

<
```
~queue(void);
```
>
Уничтожает очередь, освобождает все узлы из свободного списка.

`queue` private member functions

BOOST_STATIC_ASSERT((boost::has_trivial_destructor<T>::value));

BOOST_STATIC_ASSERT((boost::has_trivial_assign<T>::value));

structBOOST_ALIGNMENT(BOOST_LOCKFREE_CACHELINE_BYTES);

<
```
voidinitialize(void);
```
>

BOOST_DELETED_FUNCTION(queue(queueconst&));

boolis_lock_free(void)const;

Предупреждение

Проверяется только в том случае, если головка и хвостовые узлы очереди и свободный список могут быть изменены без блокировки. На большинстве платформ вся реализация без блокировки, если это правда. Используя атомы в стиле c++0x, невозможно обеспечить полностью точную реализацию, потому что нужно будет протестировать каждый внутренний узел, что невозможно, если из операционной системы будут выделены дополнительные узлы.

Возвращается:

верно, если реализация не заблокирована.

```
voidreserve(size_typen);
```
Выделить n узлов для свободного списка
Примечание
безвредный поток, может блокировать, если блоки распределителя памяти
Требует:
только действительный, если нет емкости
<
```
voidreserve_unsafe(size_typen);
```
>
Выделить n узлов для свободного списка
Примечание
не является нить-безопасным, может блокировать, если блоки распределителя памяти

Требует:

действителен только в том случае, если нет емкости

boolempty(void)const;

Проверьте, пуста ли очередь

	Примечание
	Результат является точным, только если ни одна другая нить не изменяет очередь. Поэтому редко целесообразно использовать это значение в программной логике.

Возвращает:

истинно, если очередь пуста, ложно иначе

boolpush(Tconst&t);

Притягивает объект t к очереди.

	Примечание
	Безопасный. Если внутренний пул памяти исчерпан и пул памяти не фиксированного размера, из ОС будет выделен новый узел. Это может быть несвободно.

Постусловия:	объект будет отодвинут в очередь, если можно выделить внутренний узел
Возврат:	верно, если операция толчка успешна.

boolbounded_push(Tconst&t);

Притягивает объект t к очереди.

	Примечание
	Безопасная и неблокирующая нить. Если внутренний пул памяти исчерпан, операция выйдет из строя

. Постусловия:	объект будет отодвинут в очередь, если можно выделить внутренний узел
Возврат:	верно, если операция толчка будет успешной.
Бросает:	, если распределитель памяти бросает

template<boolBounded>booldo_push(Tconst&t);

Требуется:	Тип U должен быть конструируемым по T и копируемым, или T должен быть конвертируемым в U
Пост-условия:	в случае успешной работы с поп-образованием объект будет скопирован в рет.
Возвращается:	верно, если операция поп-музыки успешна, ложно, если очередь пуста.

	Примечание
	Не безвредный, но неблокирующий

Постусловия:	в случае успешной работы с поп-ап, объект будет скопирован в ret.
Возвращается:	верно, если операция поп-музыки успешна, ложно, если очередь пуста.

	Примечание
	Безопасная и неблокирующая нить, если функтор безвредный и неблокирующий

	Примечание
	Безопасный для ниток и неблокирующий, если функтор безвредный и неблокирующий

	Примечание
	Безопасный и неблокирующий нить, если функтор безвредный и неблокирующий

	Примечание
	Безопасный и неблокирующий поток, если функтор безвредный и неблокирующий

Class template queue

Boost , The Boost C++ Libraries BoostBook Documentation Subset , Reference

Boost C++ Libraries

Class template queue

Synopsis

Description

queue public construct/copy/destruct

queue private member functions

queue public member functions

`queue` public construct/copy/destruct

`queue` private member functions

`queue` public member functions