LockSupport Classe

Definição

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

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

Herança

Object

Object

LockSupport

Atributos

RegisterAttribute

Comentários

Primitivas básicas de bloqueio de thread para criar bloqueios e outras classes de sincronização.

Essa classe associa, a cada thread que a usa, uma permissão (no sentido da java.util.concurrent.Semaphore Semaphore classe). Uma chamada para park retornará imediatamente se o alvará estiver disponível, consumindo-o no processo, caso contrário, ele pode>< bloquear<>. Uma chamada para unpark disponibilizar o alvará, caso ele ainda não estivesse disponível. (Ao contrário do que acontece com os Semáforos, porém, as licenças não se acumulam. Há, no máximo, um.) O uso confiável requer o uso de variáveis voláteis (ou atômicas) para controlar quando estacionar ou desestacionar. As ordens de chamadas para esses métodos são mantidas com relação a acessos variáveis voláteis, mas não necessariamente acessos variáveis não voláteis.

Métodos park e unpark fornecer meios eficientes de bloquear e desbloquear threads que não encontram os problemas que causam os métodos Thread.suspend preteridos e Thread.resume que são inutilizáveis para tais fins: Corridas entre um thread invocando park e outro thread tentando preservará a unpark vida, devido à permissão. Além disso, park retornará se o thread do chamador foi interrompido e as versões de tempo limite são suportadas. O park método também pode retornar em qualquer outro momento, por "sem motivo", portanto, em geral, deve ser invocado dentro de um loop que reverifica as condições após o retorno. Nesse sentido park serve como uma otimização de uma "espera ocupada" que não perde tanto tempo girando, mas deve ser emparelhada com uma unpark para ser eficaz.

As três formas de cada uma também oferecem suporte a um blocker parâmetro de park objeto. Esse objeto é gravado enquanto o thread é bloqueado para permitir que as ferramentas de monitoramento e diagnóstico identifiquem os motivos pelos quais os threads são bloqueados. (Tais ferramentas podem acessar bloqueadores usando o método #getBlocker(Thread).) O uso dessas formas em vez das formas originais sem esse parâmetro é fortemente encorajado. O argumento normal a ser fornecido como uma implementação dentro de blocker um bloqueio é this.

Esses métodos são projetados para serem usados como ferramentas para criar utilitários de sincronização de nível superior e não são úteis para a maioria dos aplicativos de controle de simultaneidade. O park método é projetado para uso apenas em construções do formulário:

{@code
            while (!canProceed()) {
              // ensure request to unpark is visible to other threads
              ...
              LockSupport.park(this);
            }}

onde nenhuma ação do thread que publica uma solicitação para desestacionar, antes da chamada para park, implica bloqueio ou bloqueio. Como apenas uma permissão está associada a cada thread, qualquer uso intermediário do , inclusive implicitamente por meio do carregamento de parkclasse, pode levar a um thread sem resposta (um "unpark perdido").

<b>Exemplo de uso.</b> Aqui está um esboço de uma classe de bloqueio não reentrante de primeiro a entrar:

{@code
            class FIFOMutex {
              private final AtomicBoolean locked = new AtomicBoolean(false);
              private final Queue<Thread> waiters
                = new ConcurrentLinkedQueue<>();

              public void lock() {
                boolean wasInterrupted = false;
                // publish current thread for unparkers
                waiters.add(Thread.currentThread());

                // Block while not first in queue or cannot acquire lock
                while (waiters.peek() != Thread.currentThread() ||
                       !locked.compareAndSet(false, true)) {
                  LockSupport.park(this);
                  // ignore interrupts while waiting
                  if (Thread.interrupted())
                    wasInterrupted = true;
                }

                waiters.remove();
                // ensure correct interrupt status on return
                if (wasInterrupted)
                  Thread.currentThread().interrupt();
              }

              public void unlock() {
                locked.set(false);
                LockSupport.unpark(waiters.peek());
              }

              static {
                // Reduce the risk of "lost unpark" due to classloading
                Class<?> ensureLoaded = LockSupport.class;
              }
            }}

Adicionado em 1.5.

Documentação Java para java.util.concurrent.locks.LockSupport.

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

Propriedades

Métodos

Implantações explícitas de interface

Métodos de Extensão

Aplica-se a