Ключевые слова:perl, proccess, select, io, (найти похожие документы)
From: Егор Байбара <http://www.gorinich.net>;
Newsgroups:
Date: Mon, 23 Apr 2008 17:02:14 +0000 (UTC)
Subject: Создания многозадачных и сетевых приложений на Perl средствами POE
Оригинал: http://www.gorinich.net/posts/9http://www.gorinich.net/posts/12
POE - portable multitasking and networking framework for Perl.
А по-русски, платформонезависимый фреймворк для создания многозадачных
и сетевых приложений на Perl.
POE позволяет достаточно просто и быстро создавать многозадачные
приложения, особо не задумываясь об управлении процессами и другими
приятными вещами, с которыми приходится сталкиваться при желании
написать многозадачное приложение. Всю эту нагрузку на себя берет POE,
мы лишь описываем, что мы хотим делать. В большинстве случаев все
приложение выполняется одним процессом, но при необходимости, POE умеет
порождать дочерние процессы и общаться с ними.
Но при всем при этом есть момент, который нельзя выпускать из виду при
разработке приложений на POE. POE обеспечивает невытесняющую
многозадачность. Это значит, что активное событие выполняется до тех
пор, пока оно само, по собственной инициативе, не отдаст управление
ядру для того, чтобы оно выбрало из очереди другое, готовое к
выполнению событие. Такой механизм применялся в Windows 9x. Недостатком
такого подхода является то, что если некоторое событие зациклится, это
приведет к краху всей системы. (Некоторые компоненты POE умеют так
делать, но это уже другая история.)
Основными модулями POE являются ядро POE::Kernel и сессия POE::Session.
Ядро контролирует очередь событий и их вызов, собственно ядро и
обеспечивает всю многозадачность. Сессия - это абстрактная событийная
машина. Каждую сессию можно рассматривать как самостоятельное
приложение, которое имеет свой набор методов и свою абстрактную память.
Посредством ядра сессии могут общаться между собой.
Рассмотрим простейший пример из документации:
#!/usr/bin/perl -w
use strict;
use POE;
for (1..10) {
POE::Session->create(
'inline_states' => {
'_start' => sub {
print "Session ", $_[SESSION]->ID, " has started.\n";
$_[HEAP]->{'count'} = 0;
$_[KERNEL]->yield('increment');
},
'increment' => sub {
print "Session ", $_[SESSION]->ID, " counted to", ++$_[HEAP]->{'count'}, ".\n";
$_[KERNEL]->yield('increment') if $_[HEAP]->{'count'} < 10;
},
'_stop' => sub {
print "Session ", $_[SESSION]->ID, " has stopped.\n";
},
}
);
}
POE::Kernel->run;
В этом примере сначала создается 10 сессий, после чего происходит
запуск ядра. Сессия также может быть создана и во время работы ядра.
Также сессия может быть создана внутри другой сессии, такая сессия
называется дочерней. Методы сессии описываются в параметре
inline_states. Это хеш, в котором в качестве значений используются либо
ссылки на функции либо анонимные процедуры. Для каждой сессии
"выделяется область памяти", с которой работает только эта сессия. По
сути это простая переменная в которой сессия может хранить что угодно.
Эта переменная называется HEAP, при создании сессии можно задать ее
начальное значение в параметре heap, внутри любого метода сессии к ней
можно получить доступ через $_[HEAP]. Как только ядро обнаруживает
новую сессию, оно выполняет метод _start. Как только ядро считает, что
сессия больше не потребуется и ее никто не будет вызывать, вызывается
метод _stop, после чего сессия уничтожается. В каждый момент времени
выполняется только один метод. Как только выполнение метода
заканчивается, управление возвращается ядру и оно выполняет вызов
следующего события из очереди. Также любой метод может поставить в
очередь ядра любое событие своей или чужой сессии. Обращение к ядру
осуществляется через $_[KERNEL]. Чтобы поставить сообщение в очередь
существует множество методов ядра. Но наиболее употребительные это
yield (постановка в очередь события своей сессии), post (постановка в
очередь события любой сессии), call (синхронный вызов события любой
сессии), delay (просьба вызвать метод своей сессии через определенный
промежуток времени).
Это был краткий обзор POE. В следующих статьях я постараюсь описать
некоторые компоненты POE. А пока с удовольствием отвечу на любые
вопросы.
Полную документацию и примеры использования можно найти на сайте
http://poe.perl.org/ Информация на русском языке по POE практически
отсутствует.
PS. POE - единственный фреймворк, который поддерживает графические
инструменты Tk и Gtk. Что позволяет писать на Perl многозадачные
оконные приложения.
Событийная машина POE и сетевая многозадачность.
Что такое событийная машина POE я кратко рассказывал в предыдущей части.
Под сетевой многозадачностью будем понимать параллельную обработку
входящих и/или исходящих сетевых соединений системными, либо
прикладными приложениями.
Почему именно POE? Вопрос, конечно, требующий обоснования. Для начала
рассмотрим какие вообще бывают способы обеспечения многозадачности. Я
знаю три
* параллельные процессы
* событийные машины
* многопоточность
Параллельные процессы
Это когда мы запускаем несколько экземпляров одного приложения.
Например так делает Apache при обработке параллельных запросов к
динамическим страницам. На каждый запрос порождается очередной процесс
и обрабатывает его. Т.е. все сводится к последовательной обработке
запросов большим количеством экземпляров одного приложения. Плюсы и
минусы в такой ситуации очевидны:
* простота организации (у нас нет проблем с блокировками и
синхронизацией);
* всю рутину за нас выполняет операционная система;
* большое количество процессов требует большого количества ресурсов;
* нет возможности динамически управлять процессом.
Событийные машины
Как устроена событийная машина? Ни для кого не секрет, что операционная
система позволяет в пределах одного приложения открыть несколько
потоков данных и ожидать ввода/вывода из них. В основе любой событийной
машины лежит цикл событий. Этот цикл позволяет отслеживать наличие
ввода/вывода на любом из открытых потоков. Как только фиксируется
событие ввода/вывода, управление передается участку кода, отвечающему
за обработку этого события. При такой организации есть один важный
момент. Обычно событийная машина обеспечивает невытесняющую
многозадачность. Поэтому необходимо следить, чтобы какое-нибудь событие
не заблокировало всё приложение. А то получится как во времена Windows
9x, когда одно приложение могло заблокировать всю систему.
Многопоточность
Здесь подразумевается порождение нескольких параллельных потоков в
пределах одного приложения. К плюсам можно отнести использование всеми
потоками одного адресного пространства и то, что скорость порождения
очередного потока намного выше скорости порождения нового процесса. К
минусам можно отнести проблему синхронизации потоков, в отличие от
проблемы блокирования в событийных машинах.
Программировать многопоточные приложения мне не доводилось, но имея
некоторое представление о них, мне приятнее будет повозиться с
блокировками. Но это уже исключительно субъективный взгляд. А с
многопоточностью пусть возятся программисты на java, python и ruby. Тем
более, что эти языки прямо так и просят, чтобы на них писали именно
многопоточные приложения, а не событийные машины.
Perl же больше расположен к использованию событийных машин. Одной из
таких машин является фреймворк POE, написанный Rocco Caputo.
Пришло время ответить на вопрос почему именно POE?
POE имеет очень хорошую абстракцию по классам. На CPAN можно найти
модули практически под любые задачи. Например если нам надо
организовать HTTP клиента, мы просто подключаем модуль
POE::Component::Client::HTTP. Т.о. мы как из конструктора собираем
приложение, которое способно выполнять поставленные задачи и нам
остается только описать все необходимые события. Если Вы программируете
на Perl, то писать многозадачные приложения на POE будет для Вас
сплошным удовольствием. В одной из следующих заметок я обязательно
расскажу, как написать простейшего сетевого бота на POE
Теперь о производительности. Приложение на POE способно обрабатывать
100-1000 запросов в секунду, а это очень не мало. Написание приложения
на столь высоком уровне занимает гораздо меньше времени, чем
низкоуровневая реализация. В моей практике были высоконагруженные
приложения написанные на POE. Паук, написанный на
POE::Component::Client::HTTP выжимал 17-20 Мбит/сек, и это в один
процесс!
