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

JavaObject

Object

LockSupport

Atributos

RegisterAttribute

Comentários

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

Essa classe associa, a cada thread que o usa, uma permissão (no sentido da java.util.concurrent.Semaphore Semaphore classe). Uma chamada será park retornada imediatamente se a licença estiver disponível, consumindo-a no processo; caso contrário,<ela >poderá</em> bloquear. Uma chamada para unpark disponibilizar a licença, caso ainda não estivesse disponível. (Ao contrário de 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 desapará-lo. As ordenações de chamadas a esses métodos são mantidas em 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 encontrarem os problemas que causam os métodos preteridos Thread.suspend e Thread.resume serem inutilizáveis para tais finalidades: as corridas entre um thread invocando park e outro thread tentando unpark isso preservarão a vida, devido à permissão. Além disso, park retornará se o thread do chamador tiver sido interrompido e houver suporte para versões de tempo limite. O park método também pode retornar em qualquer outro momento, por "nenhum motivo", portanto, em geral, deve ser invocado dentro de um loop que verifica novamente as condições no 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 park cada uma também dão suporte a um blocker parâmetro de objeto. Esse objeto é registrado enquanto o thread é bloqueado para permitir que ferramentas de monitoramento e diagnóstico identifiquem os motivos pelos quais os threads são bloqueados. (Essas ferramentas podem acessar bloqueadores usando o método #getBlocker(Thread).) O uso desses formulários em vez dos formulários originais sem esse parâmetro é altamente incentivado. O argumento normal a ser fornecido como uma blocker implementação de bloqueio é this.

Esses métodos foram 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 foi projetado para uso somente em construções do formulário:

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

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

<b>Uso de exemplo.</b> Aqui está um esboço de uma classe de bloqueio não reentrant primeiro a sair:

{@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.

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

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.