C очереди: реализация и что это вообще такое

.NET и C# | Архитектура Message Queuing

156

C# и .NET — Сетевое программирование — Архитектура Message Queuing

В Message Queuing сообщения записываются и читаются из специальной очереди сообщений. Сами сообщения и очереди сообщений имеют несколько атрибутов, которые требуют пояснений.

Сообщения

Сообщение посылается в очередь сообщений. Сообщение включает тело, содержащее пересылаемые данные, и метку — заголовок сообщения. В тело сообщения может быть помещена любая информация. В .NET имеется набор форматировщиков, преобразующих данные, которые помещаются в тело. Помимо метки и тела сообщение включает дополнительную информацию об отправителе, конфигурацию таймаута, идентификатор транзакции или приоритет.

Очереди сообщений содержат сообщения нескольких типов:

• Нормальное сообщение отправляется любым приложением.

• Подтверждающее сообщение (acknowledgment message) уведомляет о состоянии нормального сообщения. Подтверждающие сообщения отправляются в административные очереди, чтобы уведомить об успехе или сбое при отправке нормальных сообщений.

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

• Отчетные сообщения генерируются системой Message Queuing. К этой категории относятся тестовые сообщения и сообщения отслеживания маршрутизации.

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

Сообщения имеют два режима доставки: экспресс (express) и восстановимый (recoverable). Экспресс-сообщения доставляются очень быстро, потому что в качестве хранилища очереди используется оперативная память. Восстановимые сообщения сохраняются в файлах на каждом шаге маршрута — до тех пор, пока они не будут доставлены. Таким образом, доставка сообщений гарантируется, даже если компьютер будет перегружен или произойдет сбой сети.

Транзакционные сообщения — это специальная версия восстановимых сообщений. Благодаря транзакционным сообщениям гарантируется, что сообщения будут доставлены только однажды, и в том же порядке, в каком были отправлены. С транзакционными сообщениями приоритеты не используются.

Очередь сообщений

Очередь сообщений представляет собой своего рода «накопительный бункер» для сообщений. Сообщения, сохраняемые на диске, размещаются в каталоге <windows>\system32\msmq\storage.

Общедоступные или частные очереди обычно применяются для отправки сообщений, но существуют также и другие типы очередей.

Очередь (программирование) — Википедия

Существует несколько способов реализации очереди в языках программирования.

МассивПравить

Первый способ представляет очередь в виде массива и двух целочисленных переменных start и end.

Обычно start указывает на голову очереди, end — на элемент, который заполнится, когда в очередь войдёт новый элемент. При добавлении элемента в очередь в q[end] записывается новый элемент очереди, а end уменьшается на единицу. Если значение end становится меньше 1, то мы как бы циклически обходим массив, и значение переменной становится равным n. Извлечение элемента из очереди производится аналогично: после извлечения элемента q[start] из очереди переменная start уменьшается на 1. С такими алгоритмами одна ячейка из n всегда будет незанятой (так как очередь с n элементами невозможно отличить от пустой), что компенсируется простотой алгоритмов.

Преимущества данного метода: возможна незначительная экономия памяти по сравнению со вторым способом; проще в разработке.

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

Связный списокПравить

Второй способ основан на работе с динамической памятью. Очередь представляется в качестве линейного списка, в котором добавление/удаление элементов идет строго с соответствующих его концов.

Преимущества данного метода: размер очереди ограничен лишь объёмом памяти.

Недостатки: сложнее в разработке; требуется больше памяти; при работе с такой очередью память сильнее фрагментируется; работа с очередью несколько медленнее.

Реализация на двух стекахПравить

Методы очереди могут быть реализованы на основе двух стеков S1 и S2, как показано ниже:

Процедура enqueue(x):
    S1.push(x)

Функция dequeue():
    если S2 пуст:
        если S1 пуст:
            сообщить об ошибке: очередь пуста

        пока S1 не пуст:
            S2.push(S1.pop())

    вернуть S2.pop()

Такой способ реализации наиболее удобен в качестве основы для построения персистентной очереди^{[источник не указан 2180 дней]}.

Очередь в программировании используется, как и в реальной жизни, когда нужно совершить какие-то действия в порядке их поступления, выполнив их последовательно. Примером может служить организация событий в Windows. Когда пользователь оказывает какое-то действие на приложение, то в приложении не вызывается соответствующая процедура (ведь в этот момент приложение может совершать другие действия), а ему присылается сообщение, содержащее информацию о совершенном действии, это сообщение ставится в очередь, и только когда будут обработаны сообщения, пришедшие ранее, приложение выполнит необходимое действие.

Клавиатурный буфер BIOS организован в виде кольцевого массива, обычно длиной в 16 машинных слов, и двух указателей: на следующий элемент в нём и на первый незанятый элемент.

Дек (двусторонняя очередь).

#include «stdafx.h»

#include <iostream>

using namespace std;

const int N=5; //размер дека

struct Deque

{

int data[N]; //массив данных

int last; //указатель на конец

};

void Creation(Deque *D) //создание дека

{ D->last=0; }

bool Full(Deque *D) //проверка дека на пустоту

{

if (D->last==0) return true;

else return false;

}

void AddL(Deque *D) //добавление элемента в начало

{

if (D->last==N)

{ cout<<«\nДек заполнен\n\n»; return; }

int value;

cout<<«\nЗначение > «; cin>>value;

for (int i=D->last; i>0; i—)

D->data[i]=D->data[i-1];

D->data[0]=value;

D->last++;

cout<<endl<<«Элемент добавлен\n\n»;

}

void AddR(Deque *D) //добавление элемента в конец

{

if (D->last==N)

{ cout<<«\nДек заполнен\n\n»; return; }

int value;

cout<<«\nЗначение > «; cin>>value;

D->data[D->last++]=value;

cout<<endl<<«Элемент добавлен\n\n»;

}

void DeleteL(Deque *D) //удаление первого элемента

{

for (int i=0; i<D->last; i++) //смещение элементов

D->data[i]=D->data[i+1]; D->last—;

}

void DeleteR(Deque *D) //удаление последнего элемента

{ D->last—; }

int OutputL(Deque *D) //вывод первого элемента

{ return D->data[0]; }

int OutputR(Deque *D) //вывод последнего элемента

{ return D->data[D->last-1]; }

int Size(Deque *D) //размер дека

{ return D->last; }

//******************************************

int main() //главная функция

{

setlocale(LC_ALL,»Rus»);

Deque D;

Creation(&D);

char number;

do

{

cout<<«1. Добавить элемент в начало»<<endl;

cout<<«2. Добавить элемент в конец»<<endl;

cout<<«3. Удалить первый элемент»<<endl;

cout<<«4. Удалить последний элемент»<<endl;

cout<<«5. Вывести первый элемент»<<endl;

cout<<«6. Вывести последний элемент»<<endl;

cout<<«7. Узнать размер дека»<<endl;

cout<<«0. Выйти\n\n»;

cout<<«Номер команды > «; cin>>number;

switch (number)

{

case ‘1’: AddL(&D);

break;

//————————————————

case ‘2’: AddR(&D);

break;

//————————————————

case ‘3’:

if (Full(&D)) cout<<endl<<«Дек пуст\n\n»;

else

{

DeleteL(&D);

cout<<endl<<«Элемент удален из дека\n\n»;

} break;

//————————————————

case ‘4’:

if (Full(&D)) cout<<endl<<«Дек пуст\n\n»;

else

{

DeleteR(&D);

cout<<endl<<«Элемент удален\n\n»;

} break;

//————————————————

case ‘5’:

if (Full(&D)) cout<<endl<<«Дек пуст\n\n»;

else cout<<«\nПервый элемент: «<<OutputL(&D)<<«\n\n»;

break;

//————————————————

case ‘6’:

if (Full(&D)) cout<<endl<<«Дек пуст\n\n»;

else cout<<«\nПоследний элемент: «<<OutputR(&D)<<«\n\n»;

break;

//————————————————

case ‘7’:

if (Full(&D)) cout<<endl<<«Дек пуст\n\n»;

else cout<<«\nРазмер дека: «<<Size(&D)<<«\n\n»;

break;

//————————————————

case ‘0’: break;

default: cout<<endl<<«Команда не определена\n\n»;

break;

}

} while(number!=’0′);

system(«pause»);

}

Очередь на массиве и ее реализация на языке Си

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

Понятие очереди

Очередь — это последовательность, у которой включение элементов производится с одной стороны последовательности, а исключение — с другой.

Та сторона, где происходит включение элементов называется хвостом, а где происходит исключение — головой. Поначалу  многие не понимают, почему включаются элементы в хвост, а не в голову. Все просто! Давайте представим обычную очередь в буфет, в которой стоит 10 человек. Если в буфет зайдет одиннадцатый, то куда он станет? Правильно, в конец, другими словами, в хвост очереди.

Если же стек являлся структурой типа LIFO, то очередь — структура типа FIFO (от англ. First In, First Out — «Первым пришел — первым ушел»). Это вполне логично, стоит лишь вспомнить описанный выше пример с очередью в буфете.

Реализация очереди

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

Файл Queue_Array.h

/****************************************/
/*			Очередь на массиве			*/
/****************************************/
#ifndef _QUEUE_ARRAY_H_
#define _QUEUE_ARRAY_H_
/*Размер очереди*/
#define SIZE_QUEUE_ARRAY 3
/*Описание исключительных ситуаций*/
const int okQueueArray = 0;									// Все нормально
const int fullQueueArray = 1;								// Очередь переполнена
const int emptyQueueArray = 2;								// Очередь пуста
/**********************************/
/*Переменная ошибок*/
extern int errorQueueArray;
/*Базовый тип очереди*/
typedef int queueArrayBaseType;
/*Дескрипто

Стеки, Деки, Очереди | C++ для приматов

Стек

Задачи этого раздела подразумевают реализацию стеков (stack), очередей (queue) и дек (deque) на базе массивов и связных списков. Для тестирования решений используются материалы сайта e-olimp.com. После того как Вы убедились, что программа работает, необходимо отправить решение на сайт e-olimp.com для тестирования. Решение должно пройти все тесты. Программа не должна использовать каких=либо библиотечных структур данных явно или неявно предоставляющих функциональность стека или очереди. Можно использовать только массивы и связные списки.

Стек = Stack

6122. Простой стек. Для решения задачи необходимо использовать массив.
6123. Стек с защитой от ошибок. Для решения задачи необходимо использовать массив.
6124. Стек неограниченного размера Возможно использовать один из трех вариантов реализации:
      • Связный список. Недостатки: отсутствие прямого доступа к значению элемента массива по его индексу; дополнительный расход памяти на хранение ссылки на следующий элемент списка.
      • Динамические массивы с переносом значений в новый расширенный массив при переполнении исходного. Недостатки: вычислительные затраты на копирование массива; более чем удвоенный объем памяти на момент расширения хранилища.
      • Кластерная реализация: список массивов. Простая реализация стека в виде массива фиксированного размера, но с добавлением нового массива при переполнении предыдущего. Для каждого массива в списке хранится номер первого элемента в нем. Наиболее эффективный по соотношению расхода памяти и скорости работы при правильном выборе размера массивов.

Очередь = Queue

6125. Простая очередь. Для решения задачи необходимо использовать массив.
6126. Очередь с защитой от ошибок. Для решения задачи необходимо использовать массив.
6127. Очередь неограниченного размера Возможно использовать один из трех вариантов реализации:
      • Связный список. Недостатки: отсутствие прямого доступа к значению элемента массива по его индексу; дополнительный расход памяти на хранение ссылки на следующий элемент списка.
      • Динамические массивы с переносом значений в новый расширенный массив при переполнении исходного. Недостатки: вычислительные затраты на копирование массива; более чем удвоенный объем памяти на момент расширения хранилища.
      • Кластерная реализация: список массивов. Простая реализация стека в виде массива фиксированного размера, но с добавлением нового массива при переполнении предыдущего. Для каждого массива в списке хранится номер первого элемента в нем. Наиболее эффективный по соотношению расхода памяти и скорости работы при правильном выборе размера массивов.

Дек (дека) = Deque

6128. Простой дек. Для решения задачи необходимо использовать массив.
6129. Дек с защитой от ошибок. Для решения задачи необходимо использовать массив.
6130. Дек неограниченного размера Возможно использовать один из трех вариантов реализации:
      • Двунаправленный связный список. Недостатки: отсутствие прямого доступа к значению элемента массива по его индексу; дополнительный расход памяти на хранение ссылки на следующий элемент списка.
      • Динамические массивы с переносом значений в новый расширенный массив при переполнении исходного. Недостатки: вычислительные затраты на копирование массива; более чем удвоенный объем памяти на момент расширения хранилища.
      • Кластерная реализация: двунаправленный список массивов. Простая реализация стека в виде массива фиксированного размера, но с добавлением нового массива при переполнении предыдущего. Для каждого массива в списке хранится номер первого элемента в нем. Наиболее эффективный по соотношению расхода памяти и скорости работы при правильном выборе размера массивов.

Решения задач

Решения задач

6.17. Очередь и очередь с приоритетами. C++ для начинающих

6.17. Очередь и очередь с приоритетами

Абстракция очереди реализует метод доступа FIFO (first in, first out – “первым вошел, первым вышел”): объекты добавляются в конец очереди, а извлекаются из начала. Стандартная библиотека предоставляет две разновидности этого метода: очередь FIFO, или простая очередь, и очередь с приоритетами, которая позволяет сопоставлять элементы с их приоритетами. Текущий элемент помещается не в конец такой очереди, а перед элементами с более низким приоритетом. Программист, определяющий такую структуру, задает способ вычисления приоритетов. В реальной жизни подобное можно увидеть, скажем, при регистрации багажа в аэропорту. Как правило, пассажиры, чей рейс через 15 минут, передвигаются в начало очереди, чтобы не опоздать на самолет. Примером из практики программирования служит планировщик операционной системы, определяющий последовательность выполнения процессов.

Для использования queue и priority_queue необходимо включить заголовочный файл:

#include queue

Полный набор операций с контейнерами queue и priority_queue приведен в таблице 6.6.

Таблица 6.6. Операции с queue и priority_queue

Элементы priority_queue отсортированы в порядке убывания приоритетов. По умолчанию упорядочение основывается на операции “меньше”, определенной над парами элементов. Конечно, можно явно задать указатель на функцию или объект-функцию, которая будет использоваться для сортировки. (В разделе 12.3 можно найти более подробное объяснение и иллюстрации использования такой очереди.)

Поделитесь на страничке

Следующая глава >

Очередь

— класс синхронизированной очереди — документация Python 3.9.0

Исходный код: Lib / queue.py

Модуль очереди реализует очереди с несколькими производителями и потребителями.
Это особенно полезно при многопоточном программировании, когда информация должна быть
безопасный обмен между несколькими потоками. Queue класс в этом
модуль реализует всю необходимую семантику блокировки.

В модуле реализованы три типа очередей, которые различаются только порядком в
которые извлекаются.В FIFO
очереди, первые добавленные задачи извлекаются первыми. В
LIFO очередь, последняя добавленная запись
первая извлекается (работает как стек). С приоритетной очередью,
записи хранятся отсортированными (с использованием модуля heapq ) и
Сначала извлекается запись с наименьшим значением.

Внутри эти три типа очередей используют блокировки для временной блокировки
конкурирующие темы; однако они не предназначены для обработки повторного входа
внутри потока.

Кроме того, модуль реализует «простой»
FIFO типа очереди, SimpleQueue , чьи
конкретная реализация дает дополнительные гарантии
в обмен на меньший функционал.

Модуль очереди определяет следующие классы и исключения:

класс очередь. Очередь ( maxsize = 0 )

Конструктор для очереди FIFO . макс. Размер есть
целое число, устанавливающее верхнюю границу
ограничение на количество элементов, которые могут быть помещены в очередь.Вставка будет
блокировать по достижении этого размера до тех пор, пока не будут израсходованы элементы очереди. Если
maxsize меньше или равен нулю, размер очереди бесконечен.

класс очередь. LifoQueue ( макс. Размер = 0 )

Конструктор для очереди LIFO . макс. Размер есть
целое число, устанавливающее верхнюю границу
ограничение на количество элементов, которые могут быть помещены в очередь. Вставка будет
блокировать по достижении этого размера до тех пор, пока не будут израсходованы элементы очереди.Если
maxsize меньше или равен нулю, размер очереди бесконечен.

класс очередь. PriorityQueue ( maxsize = 0 )

Конструктор приоритетной очереди. maxsize — целое число, задающее верхнюю границу
ограничение на количество элементов, которые могут быть помещены в очередь. Вставка будет
блокировать по достижении этого размера до тех пор, пока не будут израсходованы элементы очереди. Если
maxsize меньше или равен нулю, размер очереди бесконечен.

Записи с наименьшим значением извлекаются первыми (запись с наименьшим значением является
один, возвращенный отсортированным (список (записи)) [0] ). Типичный шаблон для записей
представляет собой кортеж в форме: (приоритет_числа, данные) .

Если данные элементов несопоставимы, данные могут быть заключены в класс
который игнорирует элемент данных и сравнивает только номер приоритета:

 из dataclasses import dataclass, field
от ввода import Any

@dataclass (порядок = Истина)
класс PrioritizedItem:
    приоритет: int
    item: Any = field (compare = False)
 

класс очередь. SimpleQueue

Конструктор для неограниченной очереди FIFO .
В простых очередях отсутствуют расширенные функции, такие как отслеживание задач.

исключение очередь. Пустой

8.10. Queue — синхронизированный класс очереди — документация Python 2.7.18

Примечание

Модуль Queue был переименован в queue в Python 3.
Инструмент 2to3 автоматически адаптирует импорт при преобразовании вашего
исходники для Python 3.

Исходный код: Lib / Queue.py

Модуль Queue реализует очереди с несколькими производителями и потребителями.
Это особенно полезно при многопоточном программировании, когда информация должна быть
безопасный обмен между несколькими потоками. Queue класс в этом
модуль реализует всю необходимую семантику блокировки. Это зависит от
наличие поддержки потоков в Python; см. резьбу
модуль.

В модуле реализованы три типа очередей, которые различаются только порядком в
которые извлекаются.В очередь FIFO добавляются первые задачи:
первый извлечен. В очереди LIFO последняя добавленная запись
первая извлекается (работает как стек). С приоритетной очередью,
записи хранятся отсортированными (с использованием модуля heapq ) и
Сначала извлекается запись с наименьшим значением.

Модуль Queue определяет следующие классы и исключения:

класс Очередь. Очередь ( maxsize = 0 )

Конструктор очереди FIFO. maxsize — целое число, задающее верхнюю границу
ограничение на количество элементов, которые могут быть помещены в очередь. Вставка будет
блокировать по достижении этого размера до тех пор, пока не будут израсходованы элементы очереди. Если
maxsize меньше или равен нулю, размер очереди бесконечен.

класс Очередь. LifoQueue ( макс. Размер = 0 )

Конструктор очереди LIFO. maxsize — целое число, задающее верхнюю границу
ограничение на количество элементов, которые могут быть помещены в очередь.Вставка будет
блокировать по достижении этого размера до тех пор, пока не будут израсходованы элементы очереди. Если
maxsize меньше или равен нулю, размер очереди бесконечен.

класс Очередь. PriorityQueue ( maxsize = 0 )

Конструктор приоритетной очереди. maxsize — целое число, задающее верхнюю границу
ограничение на количество элементов, которые могут быть помещены в очередь. Вставка будет
блокировать по достижении этого размера до тех пор, пока не будут израсходованы элементы очереди.Если
maxsize меньше или равен нулю, размер очереди бесконечен.

Записи с наименьшим значением извлекаются первыми (запись с наименьшим значением является
один, возвращенный отсортированным (список (записи)) [0] ). Типичный шаблон для записей
представляет собой кортеж в форме: (приоритет_числа, данные) .

исключение Очередь. Пустой

Исключение возникает при неблокировании get () (или
get_nowait () ) вызывается
на пустом объекте Queue .

исключение Очередь. Полный

Исключение возникает при неблокирующем режиме put () (или
put_nowait () ) вызывается
на объекте Queue , который заполнен.

См. Также

collections.deque — альтернативная реализация неограниченного
очереди с быстрыми атомарными операциями append () и popleft () , которые
не требуют блокировки.

8.10.1. Объекты очереди

Объектов очереди ( Queue , LifoQueue или PriorityQueue )
предоставить общедоступные методы, описанные ниже.

Очередь. размер ()

Вернуть приблизительный размер очереди. Обратите внимание, qsize ()> 0 не
гарантировать, что последующий get () не будет блокироваться, а также qsize ()

Очередь. пустой ()

Вернуть Истина , если очередь пуста, Ложь в противном случае. Если пусто ()
возвращает True , это не гарантирует, что последующий вызов put ()
не будет блокировать. Точно так же, если empty () возвращает Ложь , он не
гарантировать, что последующий вызов get () не заблокируется.

Очередь. полный ()

Вернуть True , если очередь заполнена, False в противном случае.Если полный ()
возвращает True , это не гарантирует, что последующий вызов get ()
не будет блокировать. Точно так же, если full () возвращает False , он не
гарантировать, что последующий вызов put () не заблокируется.

Очередь. put ( item [, block [, timeout ]])

Поместите товар в очередь. Если необязательный аргумент , блок истинен и тайм-аут равен
Нет (по умолчанию), при необходимости заблокируйте, пока не станет доступен свободный слот.Если
тайм-аут — положительное число, он блокирует максимум тайм-аут секунд и вызывает
исключение Full , если в это время не было свободного слота.
В противном случае ( блок ложен), поместите элемент в очередь, если свободный слот
доступно немедленно, иначе вызовет исключение Full (таймаут равен
игнорируется в этом случае).

Очереди — документация Python 3.9.0

Исходный код: Lib / asyncio / queues.py

асинхронных очередей спроектированы так, чтобы быть похожими на классы
очередь модуль. Хотя очереди asyncio не являются потокобезопасными,
они предназначены для использования именно в коде async / await.

Обратите внимание, что методы асинхронных очередей не имеют параметра timeout ;
используйте функцию asyncio.wait_for () для выполнения операций с очередью с
тайм-аут.

См. Также раздел «Примеры» ниже.

Очередь

класс asyncio. Очередь ( maxsize = 0 , * , loop = None )

Очередь «первым пришел — первым ушел» (FIFO).

Если maxsize меньше или равно нулю, размер очереди равен
бесконечно. Если это целое число больше 0 , то
await put () блоков, когда очередь достигает maxsize
пока элемент не будет удален с помощью get () .

В отличие от стандартной библиотеки потоковой передачи , очереди , размер
очередь всегда известна и может быть возвращена путем вызова
qsize () метод.

Не рекомендуется с версии 3.8, будет удален в версии 3.10: параметр loop .

Этот класс не является потокобезопасным.

макс. Размер

Количество элементов, разрешенных в очереди.

пустой ()

Вернуть Истина , если очередь пуста, Ложь в противном случае.

полный ()

Вернуть True , если в очереди элементов максимального размера .

Если очередь была инициализирована с maxsize = 0 (по умолчанию),
тогда full () никогда не возвращает True .

сопрограмма получить ()

Удалить и вернуть элемент из очереди. Если очередь пуста,
подождите, пока элемент станет доступен.

get_nowait ()

Верните предмет, если он доступен сразу, иначе поднимите
QueueEmpty .

сопрограмма присоединиться ()

Блокировать до тех пор, пока все элементы в очереди не будут получены и обработаны.

Количество незавершенных задач увеличивается всякий раз, когда добавляется элемент
в очередь. Счетчик уменьшается всякий раз, когда пользовательская сопрограмма вызывает
task_done () , чтобы указать, что элемент был получен и все
работа над ним завершена. Когда количество незавершенных задач падает
до нуля, join () разблокирует.

сопрограмма пут ( элемент )

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

put_nowait ( товар )

Поставить элемент в очередь без блокировки.

Если сразу нет свободного слота, поднимите QueueFull .

размер ()

Вернуть количество элементов в очереди.

task_done ()

Указывает, что задача, ранее поставленная в очередь, завершена.

Используется потребителями очереди. Для каждого get () используется для
получить задачу, последующий вызов task_done () сообщает
очередь, что обработка задачи завершена.

Если join () в настоящее время блокируется, он возобновится, когда все
элементы были обработаны (это означает, что task_done ()
звонок был получен для каждой позиции, которая была put ()
в очередь).

Вызывает ValueError , если вызывается больше раз, чем было
элементы помещены в очередь.

Приоритетная очередь

класс asyncio. PriorityQueue

Вариант Очередь ; извлекает записи в порядке приоритета
(сначала самый низкий).

Записи обычно представляют собой кортежи вида
(приоритет_номер, данные) .

Очередь LIFO

класс asyncio. LifoQueue

Вариант Queue , извлекающий последние добавленные
записи первыми (последний пришел, первый ушел).

Исключения

исключение asyncio. Очередь пуста

Это исключение возникает, когда метод get_nowait ()
вызывается в пустой очереди.

Краткое руководство: библиотека хранилища очередей Azure версии 12 — Python

• 10.12.2019
• 8 минут на чтение

В этой статье

Начните работу с клиентской библиотекой хранилища очередей Azure версии 12 для Python.Хранилище очередей Azure — это служба для хранения большого количества сообщений для последующего извлечения и обработки. Выполните следующие действия, чтобы установить пакет и опробовать пример кода для основных задач.

Используйте клиентскую библиотеку хранилища очередей Azure версии 12 для Python, чтобы:

• Создать очередь
• Добавить сообщения в очередь
• Просмотр сообщений в очереди
• Обновить сообщение в очереди
• Получать сообщения из очереди
• Удалить сообщения из очереди
• Удалить очередь

Дополнительные ресурсы:

Предварительные требования

Настройка

В этом разделе описывается подготовка проекта к работе с клиентской библиотекой хранилища очередей Azure версии 12 для Python.

Создать проект

Создайте приложение Python с именем queues-quickstart-v12 .

1. В окне консоли (например, cmd, PowerShell или Bash) создайте новый каталог для проекта.

     mkdir queues-quickstart-v12
     

2. Переключитесь во вновь созданный каталог queues-quickstart-v12 .

     очереди компакт-дисков-quickstart-v12
     

Установить пакет

Установите клиентскую библиотеку хранилища BLOB-объектов Azure для пакета Python с помощью команды pip install .

  pip install azure-storage-queue
  

Эта команда устанавливает клиентскую библиотеку хранилища очередей Azure для пакета Python и все библиотеки, от которых она зависит. В данном случае это просто основная библиотека Azure для Python.

Настройка платформы приложения

1. Откройте новый текстовый файл в редакторе кода

2. Добавить импорт выписки

3. Создание структуры программы, включая очень простую обработку исключений

   Вот код:

     импорт ОС, uuid
   из лазурного.storage.queue импорт QueueServiceClient, QueueClient, QueueMessage
   
   пытаться:
       print ("Хранилище очередей Azure версии 12 - пример быстрого запуска Python")
       # Код быстрого запуска находится здесь
   кроме исключения как ex:
       print ('Исключение:')
       печать (например)
   
     

4. Сохраните новый файл как queues-quickstart-v12.py в каталоге queues-quickstart-v12 .

Скопируйте свои учетные данные с портала Azure

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

1. Войдите на портал Azure.

2. Найдите свою учетную запись хранения.

3. В разделе Настройки обзора учетной записи хранения выберите Ключи доступа . Здесь вы можете просмотреть ключи доступа к своей учетной записи и полную строку подключения для каждого ключа.

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

Настройте строку подключения к системе хранения

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

Окна

  setx AZURE_STORAGE_CONNECTION_STRING "<ваша строка подключения>"
  

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

Linux

  экспорт AZURE_STORAGE_CONNECTION_STRING = ""
  

macOS

  экспорт AZURE_STORAGE_CONNECTION_STRING = ""
  

Программы перезапуска

После добавления переменной среды перезапустите все запущенные программы, которым необходимо прочитать переменную среды.Например, перед продолжением перезапустите среду разработки или редактор.

Модель объекта

Хранилище очередей Azure — это служба для хранения большого количества сообщений. Сообщение в очереди может иметь размер до 64 КБ. Очередь может содержать миллионы сообщений, вплоть до предела общей емкости учетной записи хранения. Очереди обычно используются для создания отложенной работы для асинхронной обработки. Хранилище очередей предлагает три типа ресурсов:

• Учетная запись хранения
• Очередь в учетной записи хранения
• Сообщения в очереди

На следующей диаграмме показана взаимосвязь между этими ресурсами.

Используйте следующие классы Python для взаимодействия с этими ресурсами:

• QueueServiceClient: QueueServiceClient позволяет управлять всеми очередями в вашей учетной записи хранения.
• QueueClient: класс QueueClient позволяет управлять отдельной очередью и ее сообщениями и управлять ими.
• QueueMessage: класс QueueMessage представляет отдельные объекты, возвращаемые при вызове receive_messages в очереди.

Примеры кода

В этих примерах кода показано, как выполнять следующие действия с клиентской библиотекой хранилища очередей Azure для Python:

Получить строку подключения

Приведенный ниже код извлекает строку подключения для учетной записи хранения. Строка подключения хранится в переменной среды, созданной в разделе «Настройка строки подключения к хранилищу».

Добавьте этот код в блок try :

  # Получить строку подключения для использования с приложением.Хранилище
    # строка подключения хранится в переменной окружения на машине
    # запускает приложение AZURE_STORAGE_CONNECTION_STRING. Если
    # переменная среды создается после запуска приложения в
    # console или с Visual Studio оболочка или приложение должны быть
    # закрыт и перезагружен, чтобы учесть переменную окружения.
    connect_str = os.getenv ('AZURE_STORAGE_CONNECTION_STRING')
  

Создать очередь

Определите имя для новой очереди.В приведенном ниже коде к имени очереди добавляется значение UUID, чтобы гарантировать его уникальность.

Важно

Имена очередей могут содержать только строчные буквы, цифры и дефисы и должны начинаться с буквы или числа. Перед каждым дефисом должен стоять символ без дефиса. Имя также должно содержать от 3 до 63 символов. Дополнительные сведения об именовании очередей см. В разделе Именование очередей и метаданных.

Создайте экземпляр класса QueueClient. Затем вызовите метод create_queue, чтобы создать очередь в вашей учетной записи хранения.

Добавьте этот код в конец блока try :

  # Создать уникальное имя для очереди
    queue_name = "quickstartqueues-" + str (uuid.uuid4 ())

    print ("Создание очереди:" + queue_name)

    # Создаем экземпляр QueueClient, который будет
    # используется для создания и управления очередью
    queue_client = QueueClient.from_connection_string (connect_str, queue_name)

    # Создаем очередь
    queue_client.create_queue ()
  

Добавить сообщения в очередь

Следующий фрагмент кода добавляет сообщения в очередь путем вызова метода send_message.Он также сохраняет сообщение QueueMessage, возвращенное третьим вызовом send_message . saved_message используется для обновления содержимого сообщения позже в программе.

Добавьте этот код в конец блока try :

  print ("\ nДобавление сообщений в очередь ...")

    # Отправляем несколько сообщений в очередь
    queue_client.send_message (u "Первое сообщение")
    queue_client.send_message (u "Второе сообщение")
    saved_message = queue_client.send_message (u "Третье сообщение")
  

Просмотр сообщений в очереди

Просмотрите сообщения в очереди, вызвав метод peek_messages.Метод peek_messages извлекает одно или несколько сообщений из начала очереди, но не изменяет видимость сообщения.

Добавьте этот код в конец блока try :

  print ("\ nПроверьте сообщения в очереди ...")

    # Просматривать сообщения в очереди
    peeked_messages = queue_client.peek_messages (max_messages = 5)

    для peeked_message в peeked_messages:
        # Показать сообщение
        print ("Сообщение:" + peeked_message.содержание)
  

Обновить сообщение в очереди

Обновите содержимое сообщения, вызвав метод update_message. Метод update_message может изменить тайм-аут видимости сообщения и его содержимое. Содержимое сообщения должно быть строкой в ​​кодировке UTF-8 размером до 64 КБ. Вместе с новым содержимым передайте значения из сообщения, которое было ранее сохранено в коде. saved_message Значения определяют, какое сообщение следует обновить.

  print ("\ nОбновление третьего сообщения в очереди... ")

    # Обновить сообщение, используя сообщение, сохраненное при вызове send_message ранее
    queue_client.update_message (сохраненное_сообщение, pop_receipt = сохраненное_сообщение.pop_receipt, \
        content = "Третье сообщение обновлено")
  

Получать сообщения из очереди

Загрузите ранее добавленные сообщения, вызвав метод receive_messages.

Добавьте этот код в конец блока try :

  print ("\ nПолучение сообщений из очереди... ")

    # Получить сообщения из очереди
    messages = queue_client.receive_messages (messages_per_page = 5)
  

Удалить сообщения из очереди

Удалять сообщения из очереди после их получения и обработки. В этом случае обработка — это просто отображение сообщения на консоли.

Приложение приостанавливает ввод данных пользователем, вызывая input , прежде чем оно обработает и удалит сообщения. Перед удалением убедитесь на портале Azure, что ресурсы были созданы правильно.Любые сообщения, которые не были удалены явно, в конечном итоге снова станут видимыми в очереди, чтобы получить еще одну возможность их обработать.

Добавьте этот код в конец блока try :

  print ("\ nНажмите клавишу Enter, чтобы 'обработать' сообщения и удалить их из очереди ...")
    ввод ()

    для msg_batch в messages.by_page ():
            для сообщения в msg_batch:
                # "Обработать" сообщение
                печать (msg.content)
                # Сообщите службе, что мы закончили
                # сообщение и его можно безопасно удалить.queue_client.delete_message (сообщение)
  

Удалить очередь

Следующий код очищает ресурсы, созданные приложением, путем удаления очереди с помощью метода delete_queue.

Добавьте этот код в конец блока try и сохраните файл:

  print ("\ nНажмите клавишу Enter, чтобы удалить очередь ...")
    ввод ()

    # Очистить
    print ("Удаление очереди ...")
    queue_client.delete_queue ()

    print ("Готово")
  

Выполните код

Это приложение создает и добавляет три сообщения в очередь Azure.Код перечисляет сообщения в очереди, затем извлекает и удаляет их, прежде чем окончательно удалить очередь.

В окне консоли перейдите в каталог, содержащий файл queues-quickstart-v12.py , затем выполните следующую команду python , чтобы запустить приложение.

  очереди python-quickstart-v12.py
  

Вывод приложения аналогичен следующему примеру:

  Хранилище очередей Azure версии 12 - пример быстрого запуска Python
Создание очереди: quickstartqueues-cac365be-7ce6-4065-bd65-3756ea052cb8

Добавление сообщений в очередь...

Просматривайте сообщения в очереди ...
Сообщение: Первое сообщение
Сообщение: второе сообщение
Сообщение: Третье сообщение

Обновление третьего сообщения в очереди ...

Получение сообщений из очереди ...

Нажмите клавишу Enter, чтобы «обработать» сообщения и удалить их из очереди ...

Первое сообщение
Второе сообщение
Третье сообщение обновлено

Нажмите клавишу Enter, чтобы удалить очередь ...

Удаление очереди ...
Выполнено
  

Когда приложение приостанавливается перед получением сообщений, проверьте свою учетную запись хранения на портале Azure.Убедитесь, что сообщения находятся в очереди.

Нажмите кнопку Enter , чтобы получать и удалять сообщения. При появлении запроса снова нажмите клавишу Enter , чтобы удалить очередь и завершить демонстрацию.

Следующие шаги

В этом кратком руководстве вы узнали, как создать очередь и добавлять в нее сообщения с помощью кода Python. Затем вы научились просматривать, извлекать и удалять сообщения. Наконец, вы узнали, как удалить очередь сообщений.

Чтобы найти учебные пособия, образцы, краткие инструкции и другую документацию, посетите:

RabbitMQ tutorial — Рабочие очереди — RabbitMQ

Рабочие очереди

(с использованием клиента Pika Python)

Предварительные требования

В этом руководстве предполагается, что RabbitMQ установлен и запущен
на localhost на стандартный порт (5672).Если вы используете
другой хост, порт или учетные данные, настройки подключений потребуют настройки.

Куда обратиться за помощью

Если у вас возникли проблемы с прохождением этого руководства, вы можете связаться с нами через
список рассылки
или сообщество RabbitMQ Slack.

Предварительные требования

Как и в других руководствах по Python, мы будем использовать клиент Pika RabbitMQ.
версия 1.0.0.

digraph {
bgcolor = прозрачный;
truecolor = true;
rankdir = LR;
узел [style = «fill»];
//
P1 [метка = «P», fillcolor = «# 00ffff»];
Q1 [label = «{||||}}», fillcolor = «red», shape = «record»];
C1 [label = 1 >, fillcolor = «# 33ccff»];
C2 [label = 2 >, fillcolor = «# 33ccff»];
//
P1 -> Q1 -> C1;
Q1 -> C2;
}

На чем ориентировано данное руководство

В первом уроке мы
писал программы для отправки и получения сообщений из именованной очереди.В этом
один мы создадим Work Queue , который будет использоваться для распределения
трудоемкие задачи между несколькими работниками.

Основная идея рабочих очередей (также известных как Task Queues ) — избегать
немедленно выполнять ресурсоемкую задачу и ждать
это завершить. Вместо этого мы планируем выполнение задачи позже. Мы инкапсулируем
задача как сообщение и отправить его в очередь. Рабочий процесс запущен
в фоновом режиме вызовет задачи и в конечном итоге выполнит
работа.Когда вы запускаете много воркеров, задачи будут разделены между ними.

Эта концепция особенно полезна в веб-приложениях, где она
невозможно выполнить сложную задачу во время короткого HTTP-запроса
окно.

В предыдущей части этого руководства мы отправили сообщение, содержащее
«Привет мир!». Теперь мы будем отправлять строки, обозначающие сложные
задачи. У нас нет реальной задачи, например, изменить размер изображений или
pdf файлы для рендеринга, так что давайте имитировать их, просто притворившись
занят — используя время.Функция sleep (). Мы возьмем количество точек
в строке как ее сложность; каждая точка будет составлять одну секунду
«работы». Например, фальшивая задача, описанная Hello …
займет три секунды.

Мы немного изменим код send.py из нашего предыдущего примера,
чтобы разрешить отправку произвольных сообщений из командной строки. Этот
программа будет планировать задачи в нашу рабочую очередь, поэтому давайте назовем ее
new_task.py:

import sys

message = '' .join (sys.argv [1:]) или "Hello World!"
канал.basic_publish (exchange = '',
                      routing_key = 'привет',
                      тело = сообщение)
print ("[x] Отправлено% r"% сообщение)
 

Наш старый скрипт receive.py также требует некоторых изменений: он должен
подделать секунду работы для каждой точки в теле сообщения. Это лопнет
сообщения из очереди и выполнить задачу, поэтому назовем его worker.py:

время импорта

def callback (ch, метод, свойства, тело):
    print ("[x] Получено% r"% body.decode ())
    время.сон (body.count (b '.'))
    print ("[x] Готово")
 

Круговая диспетчеризация

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

Сначала попробуем запустить два сценария worker.py одновременно. Oни
оба получат сообщения из очереди, но как именно? Посмотрим.

Вам нужно открыть три консоли. Двое запустят рабочий.ру
сценарий. Эти приставки будут нашими двумя потребителями — С1 и С2.

# оболочка 1
python worker.py
# => [*] Жду сообщений. Для выхода нажмите CTRL + C
 

# оболочка 2
python worker.py
# => [*] Жду сообщений. Для выхода нажмите CTRL + C
 

В третьей опубликуем новые задачи. Как только вы начали
потребителям вы можете опубликовать несколько сообщений:

# оболочка 3
python new_task.py Первое сообщение.
python new_task.py Второе сообщение ..
python new_task.py Третье сообщение...
python new_task.py Четвертое сообщение ....
python new_task.py Пятое сообщение .....
 

Посмотрим, что доставлено нашим работникам:

# оболочка 1
python worker.py
# => [*] Жду сообщений. Для выхода нажмите CTRL + C
# => [x] Получено "Первое сообщение".
# => [x] Получено "Третье сообщение ..."
# => [x] Получено 'Пятое сообщение .....'
 

# оболочка 2
python worker.py
# => [*] Жду сообщений. Для выхода нажмите CTRL + C
# => [x] Получено "Второе сообщение .."
# => [x] Получено 'Четвертое сообщение.... '
 

По умолчанию RabbitMQ отправляет каждое сообщение следующему потребителю,
в последовательности. В среднем каждый потребитель получит одинаковое количество
Сообщения. Такой способ распространения сообщений называется циклическим. Пытаться
это с тремя или более рабочими.

Подтверждение сообщения

Выполнение задачи может занять несколько секунд. Вы можете задаться вопросом, что произойдет, если
один из потребителей начинает долгую задачу и умирает, сделав ее лишь частично.
С нашим текущим кодом, как только RabbitMQ доставит сообщение потребителю, он
сразу помечает его для удаления.В этом случае, если вы убьете рабочего
мы потеряем сообщение, которое оно только что обрабатывало. Мы также потеряем все
сообщения, которые были отправлены этому конкретному исполнителю, но не были
пока не справился.

Но мы не хотим терять задачи. Если рабочий умирает, мы хотели бы
задача будет доставлена ​​другому работнику.

Чтобы сообщение никогда не потерялось, RabbitMQ поддерживает
сообщение подтверждения . Подтверждение (подтверждение) отправляется обратно
потребитель, чтобы сообщить RabbitMQ, что было получено определенное сообщение,
обработано, и RabbitMQ может его удалить.

Если потребитель умирает (его канал закрывается, соединение закрывается, или
TCP-соединение потеряно) без отправки подтверждения RabbitMQ выполнит
поймете, что сообщение не было обработано полностью, и снова поставит его в очередь.
Если в то же время в сети есть другие потребители, он быстро восстановит его.
другому потребителю. Так вы можете быть уверены, что сообщение не потеряно,
даже если рабочие время от времени умирают.

Нет таймаутов сообщений; RabbitMQ повторно доставит сообщение, когда
потребитель умирает.Это нормально, даже если обработка сообщения занимает очень, очень
много времени.

Подтверждение сообщений вручную включено по умолчанию. В предыдущем
примеры мы явно отключили их с помощью auto_ack = True
флаг. Пришло время снять этот флаг и отправить надлежащее подтверждение
от рабочего, как только мы закончили с задачей.

def callback (ch, метод, свойства, тело):
    print ("[x] Получено% r"% body.decode ())
    time.sleep (body.count ('.'))
    print ("[x] Готово")
    ch.basic_ack (delivery_tag = method.delivery_tag)

channel.basic_consume (queue = 'hello', on_message_callback = обратный вызов)
 

Используя этот код, мы можем быть уверены, что даже если вы убьете воркера, используя
CTRL + C во время обработки сообщения ничего не потеряется. Скоро
после смерти воркера все неподтвержденные сообщения будут доставлены повторно.

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

Забытые подтверждения

Пропустить basic_ack — распространенная ошибка. Это простая ошибка,
но последствия серьезны. Сообщения будут доставлены повторно
когда ваш клиент уходит (что может выглядеть как случайная повторная доставка), но
RabbitMQ будет есть все больше и больше памяти, так как не сможет освободить
любые незапакованные сообщения.

Для отладки такого рода ошибок вы можете использовать rabbitmqctl
для печати поля messages_unacknowledged:

sudo rabbitmqctl list_queues имя messages_ready messages_unacknowledged
 

В Windows бросьте sudo:

rabbitmqctl.bat list_queues имя messages_ready messages_unacknowledged
 

Надежность сообщений

Мы узнали, как сделать так, чтобы даже в случае смерти потребителя
задача не потеряна. Но наши задачи все равно будут потеряны, если RabbitMQ server
останавливается.

Когда RabbitMQ завершает работу или аварийно завершает работу, он забывает очереди и сообщения
если вы не скажете этого не делать. Чтобы убедиться, что
сообщения не теряются: нам нужно пометить и очередь, и сообщения как
прочный.

Во-первых, нам нужно убедиться, что очередь выдержит перезапуск узла RabbitMQ.Для этого нам нужно объявить его как Durable :

.

channel.queue_declare (очередь = 'привет', прочный = Истина)
 

Хотя эта команда правильна сама по себе, она не будет работать в нашем
настроить. Это потому, что мы уже определили очередь под названием hello
который не долговечен. RabbitMQ не позволяет вам переопределить существующую очередь
с разными параметрами и вернет ошибку любой программе
который пытается это сделать. Но есть быстрый обходной путь — объявим
очередь с другим именем, например task_queue:

канал.queue_declare (queue = 'task_queue', прочный = True)
 

Это изменение queue_declare необходимо применить как к производителю
и потребительский код.

На этом этапе мы уверены, что очередь task_queue не будет потеряна
даже если RabbitMQ перезапустится. Теперь нам нужно пометить наши сообщения как постоянные
— предоставив свойству delivery_mode значение 2.

channel.basic_publish (exchange = '',
                      routing_key = "task_queue",
                      body = сообщение,
                      properties = pika.BasicProperties (
                         delivery_mode = 2, # сделать сообщение постоянным
                      ))
 

Примечание о постоянстве сообщения

Пометка сообщений как постоянных не гарантирует, что сообщение
не пропадет. Хотя он сообщает RabbitMQ о необходимости сохранения сообщения на диск,
есть еще небольшое временное окно, когда RabbitMQ принял сообщение и
еще не сохранил. Кроме того, RabbitMQ не выполняет fsync (2) для каждого
сообщение — оно может быть просто сохранено в кеш, а не записано в
диск.Гарантии настойчивости не сильны, но этого более чем достаточно
для нашей простой очереди задач. Если вам нужна более строгая гарантия, вы можете использовать
издатель подтверждает.

Справедливая отправка

Вы могли заметить, что отправка по-прежнему не работает точно
как мы хотим. Например, в ситуации с двумя рабочими, когда все
нечетные сообщения тяжелые, а четные сообщения легкие, один рабочий будет
постоянно занят, а другой почти не будет работать. Что ж,
RabbitMQ ничего об этом не знает и все равно отправит
сообщения равномерно.

Это происходит потому, что RabbitMQ просто отправляет сообщение, когда сообщение
входит в очередь. Он не учитывает количество неподтвержденных
сообщения для потребителя. Он просто слепо отправляет каждое n-е сообщение
n-му потребителю.

digraph {
bgcolor = прозрачный;
truecolor = true;
rankdir = LR;
узел [style = «fill»];
//
P1 [метка = «P», fillcolor = «# 00ffff»];
subgraph cluster_Q1 {
label = «queue_name = hello»;
цвет = прозрачный;
Q1 [label = «{||||}}», fillcolor = «red», shape = «record»];
};
C1 [label = 1 >, fillcolor = «# 33ccff»];
C2 [label = 2 >, fillcolor = «# 33ccff»];
//
P1 -> Q1;
Q1 -> C1 [label = «prefetch = 1»];
Q1 -> C2 [label = «prefetch = 1»];
}

Чтобы победить это, мы можем использовать метод канала Channel # basic_qos с
prefetch_count = 1 параметр.Это использует метод протокола basic.qos, чтобы сообщить RabbitMQ
не передавать работнику более одного сообщения за раз. Или, другими словами, не

std :: queue — cppreference.com

Класс std :: queue — это контейнерный адаптер, который дает программисту функциональность очереди, а именно структуру данных FIFO (first-in, first-out).

Шаблон класса действует как оболочка для базового контейнера — предоставляется только определенный набор функций. Очередь подталкивает элементы к задней части нижележащего контейнера и выталкивает их спереди.

[править] Параметры шаблона

[править] Типы элементов

[править] Функции-члены

.