Phaser Classe

Definição

[Android.Runtime.Register("java/util/concurrent/Phaser", DoNotGenerateAcw=true)]
public class Phaser : Java.Lang.Object

[<Android.Runtime.Register("java/util/concurrent/Phaser", DoNotGenerateAcw=true)>]
type Phaser = class
    inherit Object

Herança

Object

JavaObject

Object

Phaser

Atributos

RegisterAttribute

Comentários

Uma barreira de sincronização reutilizável, semelhante à funcionalidade e CyclicBarrier ao CountDownLatch uso mais flexível.

<b>Registro.</b> Diferentemente do caso de outras barreiras, o número de partes em registradas<></em> para sincronizar em um phaser pode variar ao longo do tempo. As tarefas podem ser registradas a qualquer momento (usando métodos #register, #bulkRegisterou formulários de construtores estabelecendo números iniciais de partes) e, opcionalmente, desregistrados em qualquer chegada (usando #arriveAndDeregister). Como é o caso dos constructos de sincronização mais básicos, o registro e o cancelamento do registro afetam apenas as contagens internas; eles não estabelecem mais nenhuma contabilidade interna, portanto, as tarefas não podem consultar se estão registradas. (No entanto, você pode introduzir essa contabilidade subclasse desta classe.)

<b>Sincronização.</b> Como um CyclicBarrier, um Phaser pode ser aguardado repetidamente. O método #arriveAndAwaitAdvance tem efeito análogo a java.util.concurrent.CyclicBarrier#await CyclicBarrier.await. Cada geração de um phaser tem um número de fase associado. O número da fase começa em zero e avança quando todas as partes chegam ao phaser, encapsulando em torno de zero depois de atingir Integer.MAX_VALUE. O uso de números de fase permite o controle independente de ações na chegada a um phaser e ao aguardar outras pessoas, por meio de dois tipos de métodos que podem ser invocados por qualquer parte registrada:

<ul>

<li><b>Chegada.</b> Métodos #arrive e #arriveAndDeregister chegada de registro. Esses métodos não bloqueiam, mas retornam um número</em> da fase de chegada associado<>; ou seja, o número de fase do phaser ao qual a chegada foi aplicada. Quando a parte final de uma determinada fase chega, uma ação opcional é executada e a fase avança. Essas ações são executadas pela parte que dispara um avanço de fase e são organizadas pelo método #onAdvance(int, int)de substituição, que também controla o encerramento. Substituir esse método é semelhante, mas mais flexível do que, fornecendo uma ação de barreira a um CyclicBarrier.

<li><b>Aguardando.<O método > /b#awaitAdvance requer um argumento que indica um número de fase de chegada e retorna quando o phaser avança para (ou já está em) uma fase diferente. Ao contrário das construções semelhantes que usam CyclicBarrier, o método awaitAdvance continua aguardando mesmo que o thread de espera seja interrompido. Versões interruptíveis e tempo limite também estão disponíveis, mas exceções encontradas enquanto as tarefas esperam com interrupção ou com o tempo limite não alteram o estado do phaser. Se necessário, você pode executar qualquer recuperação associada dentro de manipuladores dessas exceções, muitas vezes depois de invocar forceTermination. Os phasers também podem ser usados por tarefas em execução em um ForkJoinPool. O progresso será garantido se o nível de paralelismo do pool puder acomodar o número máximo de partes bloqueadas simultaneamente.

</ul>

<b>Terminação.</b> O phaser A pode inserir um <estado em>terminação</em> , que pode ser verificado usando o método #isTerminated. Após a terminação, todos os métodos de sincronização retornam imediatamente sem aguardar o avanço, conforme indicado por um valor de retorno negativo. Da mesma forma, as tentativas de registro após a terminação não têm efeito. A terminação é disparada quando uma invocação de onAdvance retorna true. A implementação padrão retornará true se um cancelamento de registro tiver feito com que o número de partes registradas se torne zero. Conforme ilustrado abaixo, quando os phasers controlam ações com um número fixo de iterações, geralmente é conveniente substituir esse método para causar terminação quando o número de fase atual atinge um limite. O método #forceTermination também está disponível para liberar abruptamente threads de espera e permitir que eles terminem.

<b>Camadas.</b> Os phasers podem ser <em>camadas</em> (ou seja, construídos em estruturas de árvore) para reduzir a contenção. Os phasers com um grande número de partes que, de outra forma, experimentariam custos pesados de contenção de sincronização podem, em vez disso, ser configurados para que grupos de sub-phasers compartilhem um pai comum. Isso pode aumentar muito a taxa de transferência, embora incorra em maior sobrecarga por operação.

Em uma árvore de phasers em camadas, o registro e o cancelamento do registro de phasers filho com seus pais são gerenciados automaticamente. Sempre que o número de partes registradas de um phaser filho se torna diferente de zero (conforme estabelecido no #Phaser(Phaser,int) construtor, #registerou #bulkRegister), o phaser filho é registrado com seu pai. Sempre que o número de partes registradas se torna zero como resultado de uma invocação de #arriveAndDeregister, o phaser filho é desregistrado de seu pai.

<b>Monitoramento.</b> Embora os métodos de sincronização possam ser invocados apenas por partes registradas, o estado atual de um phaser pode ser monitorado por qualquer chamador. A qualquer momento, há #getRegisteredParties festas no total, das quais #getArrivedParties chegaram à fase atual (#getPhase). Quando as partes restantes (#getUnarrivedParties) chegam, a fase avança. Os valores retornados por esses métodos podem refletir estados transitórios e, portanto, não são em geral úteis para o controle de sincronização. O método #toString retorna instantâneos dessas consultas de estado em um formato conveniente para monitoramento informal.

Efeitos de consistência de memória: ações anteriores a qualquer forma de método <de chegada i>happen-before</i> um avanço de fase correspondente e ações onAdvance (se presente), que, por sua vez, ocorrem antes das ações após o avanço da fase.

<b>Usos de exemplo:</b>

Um Phaser pode ser usado em vez de um CountDownLatch para controlar uma ação de um tiro que atende a um número variável de partes. O idioma típico é para o método configurar isso para primeiro registrar e, em seguida, iniciar todas as ações e, em seguida, desregister, como em:

{@code
            void runTasks(List<Runnable> tasks) {
              Phaser startingGate = new Phaser(1); // "1" to register self
              // create and start threads
              for (Runnable task : tasks) {
                startingGate.register();
                new Thread(() -> {
                  startingGate.arriveAndAwaitAdvance();
                  task.run();
                }).start();
              }

              // deregister self to allow threads to proceed
              startingGate.arriveAndDeregister();
            }}

Uma maneira de fazer com que um conjunto de threads execute ações repetidamente para um determinado número de iterações é substituir onAdvance:

{@code
            void startTasks(List<Runnable> tasks, int iterations) {
              Phaser phaser = new Phaser() {
                protected boolean onAdvance(int phase, int registeredParties) {
                  return phase >= iterations - 1 || registeredParties == 0;
                }
              };
              phaser.register();
              for (Runnable task : tasks) {
                phaser.register();
                new Thread(() -> {
                  do {
                    task.run();
                    phaser.arriveAndAwaitAdvance();
                  } while (!phaser.isTerminated());
                }).start();
              }
              // allow threads to proceed; don't wait for them
              phaser.arriveAndDeregister();
            }}

Se a tarefa principal precisar aguardar o encerramento posteriormente, ela poderá se registrar novamente e, em seguida, executar um loop semelhante:

{@code
              // ...
              phaser.register();
              while (!phaser.isTerminated())
                phaser.arriveAndAwaitAdvance();}

As construções relacionadas podem ser usadas para aguardar números de fase específicos em contextos em que você tem certeza de que a fase nunca será encapsulada Integer.MAX_VALUE. Por exemplo:

{@code
            void awaitPhase(Phaser phaser, int phase) {
              int p = phaser.register(); // assumes caller not already registered
              while (p < phase) {
                if (phaser.isTerminated())
                  // ... deal with unexpected termination
                else
                  p = phaser.arriveAndAwaitAdvance();
              }
              phaser.arriveAndDeregister();
            }}

Para criar um conjunto de n tarefas usando uma árvore de phasers, você pode usar o código do formulário a seguir, supondo uma classe Task com um construtor aceitando um Phaser que ele registra durante a construção. Após a invocação, build(new Task[n], 0, n, new Phaser())essas tarefas podem ser iniciadas, por exemplo, enviando para um pool:

{@code
            void build(Task[] tasks, int lo, int hi, Phaser ph) {
              if (hi - lo > TASKS_PER_PHASER) {
                for (int i = lo; i < hi; i += TASKS_PER_PHASER) {
                  int j = Math.min(i + TASKS_PER_PHASER, hi);
                  build(tasks, i, j, new Phaser(ph));
                }
              } else {
                for (int i = lo; i < hi; ++i)
                  tasks[i] = new Task(ph);
                  // assumes new Task(ph) performs ph.register()
              }
            }}

O melhor valor depende principalmente das TASKS_PER_PHASER taxas de sincronização esperadas. Um valor tão baixo quanto quatro pode ser apropriado para corpos de tarefas extremamente pequenos por fase (portanto, altas taxas) ou até centenas para os extremamente grandes.

<b>Notas de implementação:</b> Essa implementação restringe o número máximo de partes a 65535. Tentativas de registrar outras partes resultam em IllegalStateException. No entanto, você pode e deve criar phasers em camadas para acomodar conjuntos arbitrariamente grandes de participantes.

Adicionado em 1.7.

Java documentação para java.util.concurrent.Phaser.

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na Creative Commons 2.5.