PHP 8.4.0 RC4 available for testing

A classe Ev

(PECL ev >= 0.2.0)

Introdução

Ev é uma classe estática que fornece acesso ao loop padrão e a algumas operações comuns.

Resumo da classe

final class Ev {
/* Constantes */
const int FLAG_AUTO = 0;
const int FLAG_NOENV = 16777216;
const int FLAG_FORKCHECK = 33554432;
const int FLAG_NOINOTIFY = 1048576;
const int FLAG_SIGNALFD = 2097152;
const int FLAG_NOSIGMASK = 4194304;
const int RUN_NOWAIT = 1;
const int RUN_ONCE = 2;
const int BREAK_CANCEL = 0;
const int BREAK_ONE = 1;
const int BREAK_ALL = 2;
const int MINPRI = -2;
const int MAXPRI = 2;
const int READ = 1;
const int WRITE = 2;
const int TIMER = 256;
const int PERIODIC = 512;
const int SIGNAL = 1024;
const int CHILD = 2048;
const int STAT = 4096;
const int IDLE = 8192;
const int PREPARE = 16384;
const int CHECK = 32768;
const int EMBED = 65536;
const int CUSTOM = 16777216;
const int ERROR = 2147483648;
const int BACKEND_SELECT = 1;
const int BACKEND_POLL = 2;
const int BACKEND_EPOLL = 4;
const int BACKEND_KQUEUE = 8;
const int BACKEND_DEVPOLL = 16;
const int BACKEND_PORT = 32;
const int BACKEND_ALL = 63;
const int BACKEND_MASK = 65535;
/* Métodos */
final public static backend(): int
final public static depth(): int
final public static embeddableBackends(): int
final public static feedSignal( int $signum ): void
final public static feedSignalEvent( int $signum ): void
final public static iteration(): int
final public static now(): float
final public static nowUpdate(): void
final public static recommendedBackends(): int
final public static resume(): void
final public static run( int $flags = ?): void
final public static sleep( float $seconds ): void
final public static stop( int $how = ?): void
final public static supportedBackends(): int
final public static suspend(): void
final public static time(): float
final public static verify(): void
}

Constantes pré-definidas

Opções passadas para criar um loop:

Ev::FLAG_AUTO

O valor das opções padrão

Ev::FLAG_NOENV

Se esta opção for usada (ou o programa executar setuid ou setgid), libev não irá olhar para a variável de ambiente LIBEV_FLAGS. Caso contrário (por padrão), LIBEV_FLAGS substituirá os sinalizadores completamente se for encontrado. Útil para testes de desempenho e busca de bugs.

Ev::FLAG_FORKCHECK

Faz com que a libev verifique se há uma bifurcação em cada iteração, em vez de chamar EvLoop::fork() manualmente. Isso funciona chamando getpid() em cada iteração do loop e, portanto, isso pode desacelerar o loop de eventos com muitas iterações de loop, mas geralmente não é perceptível. Esta configuração de opção não pode ser substituída ou especificada na variável de ambiente LIBEV_FLAGS.

Ev::FLAG_NOINOTIFY

Quando este sinalizador é especificado, libev não tentará usar a API inotify para seu » ev_stat observadores. O sinalizador pode ser útil para conservar descritores de arquivo inotify, caso contrário, cada loop usando observadores ev_stat consome um identificador inotify.

Ev::FLAG_SIGNALFD

Quando esta flag for especificada, libev tentará usar a API signalfd para seus observadores » ev_signal (e » ev_child) Essa API fornece sinais de forma síncrona, o que a torna mais rápida e pode possibilitar a obtenção dos dados do sinal enfileirados. Também pode simplificar o tratamento de sinais com threads, desde que os sinais sejam bloqueados adequadamente nos threads. Signalfd não será usado por padrão.

Ev::FLAG_NOSIGMASK

Quando esta opção for especificada, libev evitará modificar a máscara do sinal. Especificamente, isso significa ter certeza de que os sinais estão desbloqueados antes de recebê-los.

Esse comportamento é útil para manipulação de sinal personalizado ou manipulação de sinais apenas em threads específicos.

Opções passadas para Ev::run() , ou EvLoop::run()

Ev::RUN_NOWAIT

Significa que o loop de eventos irá procurar novos eventos, irá tratar esses eventos e quaisquer outros já pendentes, mas não irá esperar e bloquear o processo caso não haja eventos e retornará após uma iteração do loop. Às vezes, isso é útil para pesquisar e lidar com novos eventos ao fazer cálculos demorados, para manter o programa responsivo.

Ev::RUN_ONCE

Significa que o loop de eventos procurará novos eventos (aguardando se necessário) e tratará desses e de quaisquer outros já pendentes. Ele bloqueará o processo até que pelo menos um novo evento chegue (que pode ser um evento interno ao próprio libev, portanto não há garantia de que um retorno de chamada registrado pelo usuário será chamado) e retornará após uma iteração do loop.

Opção passada para Ev::stop() , ou EvLoop::stop()

Ev::BREAK_CANCEL

Cancele a operação de interrupção.

Ev::BREAK_ONE

Faz com que a chamada Ev::run() (ou EvLoop::run() ) mais interna retorne.

Ev::BREAK_ALL

Faz com que todas as chamadas Ev::run() (ou EvLoop::run() ) aninhadas retornem.

Prioridades do observador:

Ev::MINPRI

Prioridade mínima permitida do observador.

Ev::MAXPRI

Prioridade máxima permitida do observador.

Máscaras de bits de eventos (recebidos):

Ev::READ

O descritor de arquivo no observador EvIo tornou-se legível.

Ev::WRITE

O descritor de arquivo no observador EvIo tornou-se gravável.

Ev::TIMER

O tempo do observador EvTimer expirou.

Ev::PERIODIC

O tempo do observador EvPeriodic expirou.

Ev::SIGNAL

Um sinal especificado em EvSignal::__construct() foi recebido.

Ev::CHILD

O pid especificado em EvChild::__construct() recebeu uma alteração de status.

Ev::STAT

O caminho especificado no observador EvStat alterou seus atributos.

Ev::IDLE

O observador EvIdle funciona quando não há nada a fazer com outros observadores.

Ev::PREPARE

Todos os observadores EvPrepare são invocados logo antes do início de Ev::run(). Assim, os observadores EvPrepare são os últimos observadores invocados antes do loop de eventos dormir ou pesquisar novos eventos.

Ev::CHECK

Todos os observadores EvCheck são enfileirados logo após Ev::run() reunir os novos eventos, mas antes de enfileirar quaisquer retornos de chamada para quaisquer eventos recebidos. Assim, os observadores EvCheck serão invocados antes de quaisquer outros observadores de prioridade igual ou inferior dentro de uma iteração do loop de eventos.

Ev::EMBED

O loop de eventos incorporado especificado no observador EvEmbed precisa de atenção.

Ev::CUSTOM

Nunca enviado (ou usado de outra forma) pela própria libev, mas pode ser usado livremente por usuários da libev para sinalizar observadores (por exemplo, via EvWatcher::feed() ).

Ev::ERROR

Ocorreu um erro não especificado, o observador foi interrompido. Isto pode acontecer porque o observador não pôde ser iniciado corretamente porque libev ficou sem memória, um descritor de arquivo foi fechado ou qualquer outro problema. Libev considera esses bugs de aplicação. Veja também » ANATOMIA DE UM OBSERVADOR

Opções de backend:

Ev::BACKEND_SELECT

select(2) backend

Ev::BACKEND_POLL

poll(2) backend

Ev::BACKEND_EPOLL

Backend epoll(7) específico do Linux para kernels pré e pós-2.6.9

Ev::BACKEND_KQUEUE

Backend kqueue usado na maioria dos sistemas BSD. O observador EvEmbed pode ser usado para incorporar um loop (com backend kqueue) em outro. Por exemplo, pode-se tentar criar um loop de eventos com backend kqueue e usá-lo apenas para sockets.

Ev::BACKEND_DEVPOLL

Back-end do Solaris 8. Isso ainda não foi implementado.

Ev::BACKEND_PORT

Mecanismo de porta de eventos Solaris 10 com bom dimensionamento.

Ev::BACKEND_ALL

Experimente todos os back-ends (mesmo os corrompidos). Não é recomendado usá-lo explicitamente. Operadores bit a bit devem ser aplicados aqui (por exemplo, Ev::BACKEND_ALL & ~ Ev::BACKEND_KQUEUE ) Use Ev::recommendedBackends() ou não não especifique nenhum back-end.

Ev::BACKEND_MASK

Não é um backend, mas uma máscara para selecionar todos os bits de backend do valor flags para mascarar quaisquer backends (por exemplo, ao modificar a variável de ambiente LIBEV_FLAGS).

Nota:

Para o loop padrão durante a fase de inicialização do módulo, Ev registra » ev_loop_fork chamada por meio de pthread_atfork (se disponível).

Nota:

Existem métodos que fornecem acesso ao loop de eventos padrão na classe Ev (por exemplo, Ev::iteration() , Ev::depth() etc.) Para loops personalizados (criados com EvLoop::__construct() ) esses valores podem ser acessados através de propriedades e métodos correspondentes da classe EvLoop.

A instância do loop de eventos padrão em si pode ser obtida por meio do método EvLoop::defaultLoop().

Índice

  • Ev::backend — Returns an integer describing the backend used by libev
  • Ev::depth — Returns recursion depth
  • Ev::embeddableBackends — Returns the set of backends that are embeddable in other event loops
  • Ev::feedSignal — Feed a signal event info Ev
  • Ev::feedSignalEvent — Feed signal event into the default loop
  • Ev::iteration — Return the number of times the default event loop has polled for new events
  • Ev::now — Returns the time when the last iteration of the default event loop has started
  • Ev::nowUpdate — Establishes the current time by querying the kernel, updating the time returned by Ev::now in the progress
  • Ev::recommendedBackends — Returns a bit mask of recommended backends for current platform
  • Ev::resume — Resume previously suspended default event loop
  • Ev::run — Begin checking for events and calling callbacks for the default loop
  • Ev::sleep — Block the process for the given number of seconds
  • Ev::stop — Stops the default event loop
  • Ev::supportedBackends — Returns the set of backends supported by current libev configuration
  • Ev::suspend — Suspend the default event loop
  • Ev::time — Returns the current time in fractional seconds since the epoch
  • Ev::verify — Performs internal consistency checks(for debugging)
adicione uma nota

Notas Enviadas por Usuários (em inglês)

Não há notas de usuários para esta página.
To Top