ForkJoinTask Classe
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Classe base abstrata para tarefas executadas em um ForkJoinPoolarquivo .
[Android.Runtime.Register("java/util/concurrent/ForkJoinTask", DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "V" })]
public abstract class ForkJoinTask : Java.Lang.Object, IDisposable, Java.Interop.IJavaPeerable, Java.IO.ISerializable, Java.Util.Concurrent.IFuture[<Android.Runtime.Register("java/util/concurrent/ForkJoinTask", DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "V" })>]
type ForkJoinTask = class
inherit Object
interface ISerializable
interface IJavaObject
interface IDisposable
interface IJavaPeerable
interface IFuture- Herança
- Derivado
- Atributos
- Implementações
Comentários
Classe base abstrata para tarefas executadas em um ForkJoinPoolarquivo . A ForkJoinTask é uma entidade semelhante a um fio que é muito mais leve do que um fio normal. Um grande número de tarefas e subtarefas pode ser hospedado por um pequeno número de threads reais em um ForkJoinPool, ao preço de algumas limitações de uso.
Um "principal" ForkJoinTask começa a ForkJoinPool#commonPool() execução quando é explicitamente submetido a um ForkJoinPool, ou, se ainda não estiver envolvido em um cálculo ForkJoin, iniciado na via #fork, #invoke, ou métodos relacionados. Uma vez iniciado, ele geralmente iniciará outras subtarefas. Como indicado pelo nome desta classe, muitos programas que usam ForkJoinTask empregam apenas métodos #fork e #join, ou derivados, como #invokeAll(ForkJoinTask...) invokeAll. No entanto, esta classe também fornece uma série de outros métodos que podem entrar em jogo em usos avançados, bem como mecânicas de extensão que permitem o suporte de novas formas de processamento de bifurcação/junção.
A ForkJoinTask é uma forma leve de Future. A eficiência de ForkJoinTasks deriva de um conjunto de restrições (que são apenas parcialmente aplicáveis estaticamente) refletindo seu uso principal como tarefas computacionais calculando funções puras ou operando em objetos puramente isolados. Os principais mecanismos de coordenação são #fork, que organiza a execução assíncrona e #join, que não prossegue até que o resultado da tarefa tenha sido computado. Os cálculos devem idealmente evitar synchronized métodos ou blocos, e devem minimizar outros bloqueios de sincronização, além de se juntar a outras tarefas ou usar sincronizadores como Phasers que são anunciados para cooperar com o agendamento de bifurcação/junção. Tarefas subdividíveis também não devem executar E/S de bloqueio e, idealmente, devem acessar variáveis que são completamente independentes daquelas acessadas por outras tarefas em execução. Essas diretrizes são aplicadas de forma frouxa, não permitindo que exceções verificadas, como IOExceptions as sejam lançadas. No entanto, os cálculos ainda podem encontrar exceções não verificadas, que são relançadas para os chamadores que tentam ingressar neles. Essas exceções também podem incluir RejectedExecutionException decorrentes do esgotamento de recursos internos, como falha na alocação de filas de tarefas internas. As exceções relançadas se comportam da mesma maneira que as exceções regulares, mas, quando possível, contêm rastreamentos de pilha (como exibido, por exemplo, usando ex.printStackTrace()) tanto do thread que iniciou a computação quanto do thread que realmente encontrou a exceção, minimamente apenas a última.
É possível definir e usar ForkJoinTasks que podem bloquear, mas isso requer três considerações adicionais: (1) A conclusão de poucas ou nenhuma <em>outras<> tarefas deve depender de uma tarefa que bloqueie a sincronização externa ou E/S. As tarefas assíncronas no estilo de evento que nunca são associadas (por exemplo, aquelas subclassificações CountedCompleter) geralmente se enquadram nessa categoria. (2) Para minimizar o impacto nos recursos, as tarefas devem ser pequenas; O ideal é executar apenas a (possivelmente) ação de bloqueio. (3) A menos que a ForkJoinPool.ManagedBlocker API seja usada, ou o número de tarefas possivelmente bloqueadas seja menor do que o nível do pool, o pool não pode garantir que threads ForkJoinPool#getParallelism suficientes estarão disponíveis para garantir o progresso ou o bom desempenho.
O principal método para aguardar a conclusão e extrair os resultados de uma tarefa é #joino , mas há várias variantes: os Future#get métodos oferecem suporte a esperas interruptíveis e/ou cronometradas para conclusão e relatam resultados usando Future convenções. O método #invoke é semanticamente equivalente, fork(); join() mas sempre tenta iniciar a execução no thread atual. As formas "<em>quiet</em>" desses métodos não extraem resultados ou relatam exceções. Eles podem ser úteis quando um conjunto de tarefas está sendo executado e você precisa atrasar o processamento de resultados ou exceções até que tudo seja concluído. Método invokeAll (disponível em várias versões) executa a forma mais comum de invocação paralela: forjar um conjunto de tarefas e uni-las todas.
Nos usos mais típicos, um par fork-join age como uma chamada (fork) e retorna (join) de uma função recursiva paralela. Como acontece com outras formas de chamadas recursivas, os retornos (junções) devem ser realizados internamente primeiro. Por exemplo, a.fork(); b.fork(); b.join(); a.join(); é provável que seja substancialmente mais eficiente do que aderir a antes b.
O status de execução das tarefas pode ser consultado em vários níveis de detalhe: #isDone é verdadeiro se uma tarefa foi concluída de alguma forma (incluindo o caso em que uma tarefa foi cancelada sem execução), #isCompletedNormally é verdadeiro se uma tarefa foi concluída sem cancelamento ou encontrando uma exceção, #isCancelled é verdadeiro se a tarefa foi cancelada (nesse caso #getException , retorna um CancellationException); e #isCompletedAbnormally é verdadeiro se uma tarefa foi cancelada ou encontrou uma exceção, nesse caso #getException , retornará a exceção encontrada ou CancellationException.
A classe ForkJoinTask geralmente não é subclassificada diretamente. Em vez disso, você subclassifique uma das classes abstratas que oferecem suporte a um estilo específico de processamento de bifurcação/junção, normalmente RecursiveAction para a maioria dos cálculos que não retornam resultados, RecursiveTask para aqueles que retornam e CountedCompleter para aqueles em que ações concluídas disparam outras ações. Normalmente, uma subclasse ForkJoinTask concreta declara campos que compreendem seus parâmetros, estabelecidos em um construtor e, em seguida, define um compute método que de alguma forma usa os métodos de controle fornecidos por essa classe base.
O método #join e suas variantes são apropriados para uso somente quando as dependências de conclusão são acíclicas, ou seja, a computação paralela pode ser descrita como um grafo acíclico direcionado (DAG). Caso contrário, as execuções podem encontrar uma forma de impasse à medida que as tarefas esperam ciclicamente umas pelas outras. No entanto, essa estrutura oferece suporte a outros métodos e técnicas (por exemplo, o uso de , #helpQuiescee #complete) que podem ser úteis na construção de subclasses personalizadas para problemas que não são estruturados Phaserestaticamente como DAGs. Para suportar tais usos, um ForkJoinTask pode ser atomicamente <marcado>< / em> com um short valor usando #setForkJoinTaskTag ou #compareAndSetForkJoinTaskTag e verificado usando #getForkJoinTaskTag. A implementação ForkJoinTask não usa esses protected métodos ou tags para qualquer finalidade, mas eles podem ser úteis na construção de subclasses especializadas. Por exemplo, travessias de grafos paralelos podem usar os métodos fornecidos para evitar revisitar nós/tarefas que já foram processadas. (Os nomes de método para marcação são volumosos em parte para incentivar a definição de métodos que refletem seus padrões de uso.)
A maioria dos métodos de suporte de base são final, para evitar a substituição de implementações que estão intrinsecamente ligadas à estrutura de agendamento de tarefas leve subjacente. Os desenvolvedores que criam novos estilos básicos de processamento fork/join devem implementar protected minimamente métodos #exec, #setRawResulte #getRawResult, enquanto também introduzem um método computacional abstrato que pode ser implementado em suas subclasses, possivelmente contando com outros protected métodos fornecidos por esta classe.
ForkJoinTasks deve executar quantidades relativamente pequenas de computação. Tarefas grandes devem ser divididas em subtarefas menores, geralmente via decomposição recursiva. Como uma regra prática muito aproximada, uma tarefa deve executar mais de 100 e menos de 10000 etapas computacionais básicas, e deve evitar looping indefinido. Se as tarefas forem muito grandes, o paralelismo não poderá melhorar a taxa de transferência. Se muito pequena, a sobrecarga de manutenção de tarefas internas e de memória pode sobrecarregar o processamento.
Essa classe fornece adapt métodos para e Callable, que podem ser úteis ao Runnable misturar a execução de ForkJoinTasks com outros tipos de tarefas. Quando todas as tarefas forem desse formato, considere o uso de um pool construído em <asyncMode<>/em>.
ForkJoinTasks são Serializable, o que permite que eles sejam usados em extensões como estruturas de execução remota. É sensato serializar tarefas apenas antes ou depois, mas não durante a execução. A serialização não é confiada durante a execução em si.
Adicionado em 1.7.
Documentação Java para java.util.concurrent.ForkJoinTask.
Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Android Open Source Project e usado de acordo com os termos descritos na Creative Commons 2.5 Attribution License.
Construtores
| ForkJoinTask() |
Construtor para subclasses a serem chamadas. |
| ForkJoinTask(IntPtr, JniHandleOwnership) |
Um construtor usado ao criar representações gerenciadas de objetos JNI; chamado pelo tempo de execução. |
Propriedades
| Class |
Retorna a classe de tempo de execução deste |
| Exception |
Retorna a exceção lançada pela computação base, ou um se cancelado, ou |
| ForkJoinTaskTag |
Retorna a marca para esta tarefa. |
| Handle |
O identificador para a instância subjacente do Android. (Herdado de Object) |
| IsCancelled |
Retorna |
| IsCompletedAbnormally |
Retorna |
| IsCompletedNormally |
Retorna |
| IsDone |
Retorna |
| JniIdentityHashCode |
Classe base abstrata para tarefas executadas em um |
| JniPeerMembers |
Classe base abstrata para tarefas executadas em um |
| PeerReference |
Classe base abstrata para tarefas executadas em um |
| Pool |
Retorna o pool que hospeda o thread atual ou |
| QueuedTaskCount |
Retorna uma estimativa do número de tarefas que foram bifurcadas pelo thread de trabalho atual, mas ainda não foram executadas. |
| RawRawResult |
Retorna o resultado que seria retornado pelo Join(), mesmo se essa tarefa foi concluída de forma anormal ou |
| SurplusQueuedTaskCount |
Retorna uma estimativa de quantas tarefas mais enfileiradas localmente são mantidas pelo thread de trabalho atual do que há outros threads de trabalho que podem roubá-las, ou zero se esse thread não estiver operando em um ForkJoinPool. |
| ThresholdClass |
Esta API suporta a infraestrutura Mono para Android e não se destina a ser usada diretamente do seu código. |
| ThresholdType |
Esta API suporta a infraestrutura Mono para Android e não se destina a ser usada diretamente do seu código. |
Métodos
| Adapt(ICallable) |
Retorna um novo |
| Adapt(IRunnable) |
Retorna um novo |
| Adapt(IRunnable, Object) |
Retorna um novo |
| Cancel(Boolean) |
Tenta cancelar a execução desta tarefa. |
| Clone() |
Cria e retorna uma cópia desse objeto. (Herdado de Object) |
| CompareAndSetForkJoinTaskTag(Int16, Int16) |
Atomicamente define condicionalmente o valor da tag para esta tarefa. |
| Complete(Object) |
Conclui essa tarefa e, se ainda não tiver sido abortada ou cancelada, retornará o valor fornecido como resultado de invocações subsequentes de |
| CompleteExceptionally(Throwable) |
Conclui essa tarefa de forma anormal e, se ainda não tiver sido abortada ou cancelada, fará com que ela lance a exceção dada sobre |
| Dispose() |
Classe base abstrata para tarefas executadas em um |
| Dispose(Boolean) |
Classe base abstrata para tarefas executadas em um |
| Equals(Object) |
Indica se algum outro objeto é "igual" a este. (Herdado de Object) |
| Exec() |
Executa imediatamente a ação base desta tarefa e retorna true se, ao retornar desse método, essa tarefa tiver a garantia de ter sido concluída. |
| Fork() |
Organiza a execução assíncrona dessa tarefa no pool em que a tarefa atual está sendo executada, se aplicável, ou usando o |
| Get() |
Aguarda, se necessário, que a computação seja concluída e, em seguida, recupera seu resultado. |
| Get(Int64, TimeUnit) |
Aguarda, se necessário, pelo máximo o tempo determinado para que a computação seja concluída e, em seguida, recupera seu resultado, se disponível. |
| GetHashCode() |
Retorna um valor de código hash para o objeto. (Herdado de Object) |
| HelpQuiesce() |
Possivelmente executa tarefas até que o pool que hospeda a tarefa atual ForkJoinPool#isQuiescent esteja quiescente. |
| InForkJoinPool() |
Retorna |
| Invoke() |
Inicia a execução dessa tarefa, aguarda sua conclusão, se necessário, e retorna seu resultado, ou lança um (desmarcado) |
| InvokeAll(ForkJoinTask, ForkJoinTask) |
Bifurca as tarefas dadas, retornando quando |
| InvokeAll(ForkJoinTask[]) |
Bifurca todas as tarefas na coleção especificada, retornando quando |
| InvokeAll(ICollection) |
Bifurca todas as tarefas na coleção especificada, retornando quando |
| JavaFinalize() |
Chamado pelo coletor de lixo em um objeto quando a coleta de lixo determina que não há mais referências ao objeto. (Herdado de Object) |
| Join() |
Retorna o resultado da computação quando #isDone é concluído. |
| Notify() |
Ativa um único thread que está aguardando no monitor deste objeto. (Herdado de Object) |
| NotifyAll() |
Ativa todos os threads que estão aguardando no monitor deste objeto. (Herdado de Object) |
| PeekNextLocalTask() |
Retorna, mas não desagenda ou executa, uma tarefa enfileirada pelo thread atual, mas ainda não executada, se uma estiver imediatamente disponível. |
| PollNextLocalTask() |
Desagenda e retorna, sem executar, a próxima tarefa enfileirada pelo thread atual, mas ainda não executada, se o thread atual estiver operando em um ForkJoinPool. |
| PollTask() |
Se o thread atual estiver operando em um ForkJoinPool, desagendará e retornará, sem executar, a próxima tarefa enfileirada pelo thread atual, mas ainda não executada, se houver uma disponível, ou se não estiver disponível, uma tarefa que foi bifurcada por algum outro thread, se disponível. |
| QuietlyComplete() |
Conclui esta tarefa normalmente sem definir um valor. |
| QuietlyInvoke() |
Inicia a execução desta tarefa e aguarda sua conclusão se necessário, sem retornar seu resultado ou lançar sua exceção. |
| QuietlyJoin() |
Junta-se a esta tarefa, sem devolver o seu resultado ou lançar a sua excepção. |
| Reinitialize() |
Redefine o estado de escrituração interna desta tarefa, permitindo um |
| SetForkJoinTaskTag(Int16) |
Atomicamente define o valor da tag para essa tarefa e retorna o valor antigo. |
| SetHandle(IntPtr, JniHandleOwnership) |
Define a propriedade Handle. (Herdado de Object) |
| SetRawResult(Object) |
Força o valor dado a ser retornado como resultado. |
| ToArray<T>() |
Classe base abstrata para tarefas executadas em um |
| ToString() |
Retorna uma representação de cadeia de caracteres do objeto. (Herdado de Object) |
| TryUnfork() |
Tenta desagendar esta tarefa para execução. |
| UnregisterFromRuntime() |
Classe base abstrata para tarefas executadas em um |
| Wait() |
Faz com que o thread atual aguarde até que ele seja ativado, normalmente sendo <em notificado</em> ou <em>interrompido</em>>. (Herdado de Object) |
| Wait(Int64) |
Faz com que o thread atual aguarde até que ele seja despertado, normalmente sendo <em>notificado</em> ou <em interrompido</em>, ou até que>uma certa quantidade de tempo real tenha decorrido. (Herdado de Object) |
| Wait(Int64, Int32) |
Faz com que o thread atual aguarde até que ele seja despertado, normalmente sendo <em>notificado</em> ou <em interrompido</em>, ou até que>uma certa quantidade de tempo real tenha decorrido. (Herdado de Object) |
Implantações explícitas de interface
| IJavaPeerable.Disposed() |
Classe base abstrata para tarefas executadas em um |
| IJavaPeerable.DisposeUnlessReferenced() |
Classe base abstrata para tarefas executadas em um |
| IJavaPeerable.Finalized() |
Classe base abstrata para tarefas executadas em um |
| IJavaPeerable.JniManagedPeerState |
Classe base abstrata para tarefas executadas em um |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Classe base abstrata para tarefas executadas em um |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Classe base abstrata para tarefas executadas em um |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Classe base abstrata para tarefas executadas em um |
Métodos de Extensão
| JavaCast<TResult>(IJavaObject) |
Executa uma conversão de tipo verificada em tempo de execução do Android. |
| JavaCast<TResult>(IJavaObject) |
Classe base abstrata para tarefas executadas em um |
| GetJniTypeName(IJavaPeerable) |
Classe base abstrata para tarefas executadas em um |
| GetAsync(IFuture) |
Classe base abstrata para tarefas executadas em um |
| GetAsync(IFuture, Int64, TimeUnit) |
Classe base abstrata para tarefas executadas em um |