ForkJoinPool.IManagedBlocker Interface

Définition

[Android.Runtime.Register("java/util/concurrent/ForkJoinPool$ManagedBlocker", "", "Java.Util.Concurrent.ForkJoinPool/IManagedBlockerInvoker")]
public interface ForkJoinPool.IManagedBlocker : Android.Runtime.IJavaObject, IDisposable, Java.Interop.IJavaPeerable

[<Android.Runtime.Register("java/util/concurrent/ForkJoinPool$ManagedBlocker", "", "Java.Util.Concurrent.ForkJoinPool/IManagedBlockerInvoker")>]
type ForkJoinPool.IManagedBlocker = interface
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Attributs

RegisterAttribute

Implémente

IJavaObject IJavaPeerable IDisposable

Remarques

Interface permettant d’étendre le parallélisme managé pour les tâches exécutées dans ForkJoinPools.

A ManagedBlocker fournit deux méthodes. La méthode #isReleasable doit retourner true si le blocage n’est pas nécessaire. La méthode #block bloque le thread actuel si nécessaire (peut-être en interne avant isReleasable de bloquer réellement). Ces actions sont effectuées par n’importe quel thread appelant ForkJoinPool#managedBlock(ManagedBlocker). Les méthodes inhabituelles de cette API prennent en charge les synchronisateurs qui peuvent, mais ne le bloquent généralement pas pendant de longues périodes. De même, ils permettent un traitement interne plus efficace des cas dans lesquels des travailleurs supplémentaires peuvent être, mais ne sont généralement pas nécessaires pour garantir un parallélisme suffisant. À cette fin, les implémentations de méthode isReleasable doivent être aménables à un appel répété. Aucune méthode n’est appelée après un appel antérieur de ou block de isReleasable retour true.

Par exemple, voici un ManagedBlocker basé sur un ReentrantLock :

{@code
            class ManagedLocker implements ManagedBlocker {
              final ReentrantLock lock;
              boolean hasLock = false;
              ManagedLocker(ReentrantLock lock) { this.lock = lock; }
              public boolean block() {
                if (!hasLock)
                  lock.lock();
                return true;
              }
              public boolean isReleasable() {
                return hasLock || (hasLock = lock.tryLock());
              }
            }}

Voici une classe qui bloque éventuellement l’attente d’un élément dans une file d’attente donnée :

{@code
            class QueueTaker<E> implements ManagedBlocker {
              final BlockingQueue<E> queue;
              volatile E item = null;
              QueueTaker(BlockingQueue<E> q) { this.queue = q; }
              public boolean block() throws InterruptedException {
                if (item == null)
                  item = queue.take();
                return true;
              }
              public boolean isReleasable() {
                return item != null || (item = queue.poll()) != null;
              }
              public E getItem() { // call after pool.managedBlock completes
                return item;
              }
            }}

Documentation Java pour java.util.concurrent.ForkJoinPool.ManagedBlocker.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

Propriétés

Méthodes

Méthodes d’extension

S’applique à