Selector Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Multiplexeur d’objets SelectableChannel .
[Android.Runtime.Register("java/nio/channels/Selector", DoNotGenerateAcw=true)]
public abstract class Selector : Java.Lang.Object, IDisposable, Java.Interop.IJavaPeerable, Java.IO.ICloseable[<Android.Runtime.Register("java/nio/channels/Selector", DoNotGenerateAcw=true)>]
type Selector = class
inherit Object
interface ICloseable
interface IJavaObject
interface IDisposable
interface IJavaPeerable- Héritage
- Dérivé
- Attributs
- Implémente
Remarques
Multiplexeur d’objets SelectableChannel .
Un sélecteur peut être créé en appelant la #open open méthode de cette classe, qui utilisera la valeur par défaut java.nio.channels.spi.SelectorProvider selector provider du système pour créer un sélecteur. Un sélecteur peut également être créé en appelant la java.nio.channels.spi.SelectorProvider#openSelector openSelector méthode d’un fournisseur de sélecteur personnalisé. Un sélecteur reste ouvert jusqu’à ce qu’il soit fermé via sa #close close méthode.
« ks »>
L’inscription d’un canal sélectionnable avec un sélecteur est représentée par un SelectionKey objet. Un sélecteur gère trois ensembles de clés de sélection :
<ul>
<Li>
Le jeu de clés contient les clés représentant les inscriptions de canal actuelles de ce sélecteur. Cet ensemble est retourné par la #keys() keys méthode.
</Li>
<Li>
L’ensemble de clés sélectionné est l’ensemble de clés de sorte que le canal de chaque clé a été détecté pour être prêt pour au moins une des opérations identifiées dans le jeu d’intérêt de la clé pendant une opération de sélection précédente qui ajoute des clés ou met à jour les clés dans le jeu. Cet ensemble est retourné par la #selectedKeys() selectedKeys méthode. Le jeu de clés sélectionné est toujours un sous-ensemble du jeu de clés.
</Li>
<Li>
L’ensemble de clés annulées est l’ensemble de clés qui ont été annulées, mais dont les canaux n’ont pas encore été désinscrits. Cet ensemble n’est pas directement accessible. Le jeu de clés annulées est toujours un sous-ensemble du jeu de clés.
</Li>
</ul>
Les trois ensembles sont vides dans un sélecteur nouvellement créé.
Une clé est ajoutée à l’ensemble de clés d’un sélecteur comme effet secondaire de l’inscription d’un canal via la méthode du SelectableChannel#register(Selector,int) register canal. Les clés annulées sont supprimées du jeu de clés pendant les opérations de sélection. L’ensemble de clés lui-même n’est pas directement modifiable.
Une clé est ajoutée à l’ensemble de clés annulées de son sélecteur lorsqu’elle est annulée, que ce soit en fermant son canal ou en appelant sa SelectionKey#cancel cancel méthode. L’annulation d’une clé entraîne l’annulation de son canal lors de la prochaine opération de sélection, à laquelle la clé sera supprimée de tous les jeux de clés du sélecteur.
« sks »>
Les clés sont ajoutées au jeu de clés sélectionné par les opérations de sélection. Une clé peut être supprimée directement de l’ensemble de clés sélectionnées en appelant la méthode du java.util.Set#remove(java.lang.Object) remove jeu ou en appelant la java.util.Iterator#remove() remove méthode d’un java.util.Iterator iterator ensemble obtenu. Toutes les clés peuvent être supprimées de l’ensemble de clés sélectionnées en appelant la méthode du java.util.Set#clear() clear jeu. Les clés peuvent ne pas être ajoutées directement au jeu de clés sélectionné.
« selop"><h2>Selection</h2>
Une opération de sélection interroge le système d’exploitation sous-jacent pour une mise à jour quant à la préparation de chaque canal inscrit pour effectuer l’une des opérations identifiées par l’ensemble d’intérêt de sa clé. Il existe deux formes d’opération de sélection :
<ol>
<Li>
Les #select()méthodes et #selectNow() les #select(long)méthodes ajoutent les clés des canaux prêts à effectuer une opération au jeu de clés sélectionné ou mettent à jour le jeu de clés prêt à l’opération déjà dans le jeu de clés sélectionné.
</Li>
<Li>
Les #select(Consumer)méthodes et #selectNow(Consumer) les méthodes #select(Consumer, long)effectuent une action sur la clé de chaque canal prêt à effectuer une opération. Ces méthodes n’ajoutent pas à l’ensemble de clés sélectionnées.
</Li>
</ol>
<Opérations de sélection h3>qui ajoutent à l’ensemble< de clés sélectionnées/h3>
Pendant chaque opération de sélection, les clés peuvent être ajoutées et supprimées de l’ensemble de clés sélectionnées d’un sélecteur et peuvent être supprimées de sa clé et des jeux de clés annulés. La sélection est effectuée par les #select()méthodes , #select(long)et #selectNow() implique trois étapes :
<ol>
<Li>
Chaque clé de l’ensemble de clés annulées est supprimée de chaque jeu de clés dont il est membre, et son canal est désinscrit. Cette étape laisse le jeu de clés annulée vide.
</Li>
<Li>
Le système d’exploitation sous-jacent est interrogé pour une mise à jour quant à la préparation de chaque canal restant pour effectuer l’une des opérations identifiées par l’ensemble d’intérêt de sa clé à partir du moment où l’opération de sélection a commencé. Pour un canal prêt pour au moins une telle opération, l’une des deux actions suivantes est effectuée :
<ol>
<Li>
Si la clé du canal n’est pas déjà dans l’ensemble de clés sélectionnées, elle est ajoutée à ce jeu et son jeu prêt à l’opération est modifié pour identifier exactement les opérations pour lesquelles le canal est maintenant signalé comme prêt. Toutes les informations de préparation précédemment enregistrées dans le jeu prêt sont ignorées.
</Li>
<Li>
Sinon, la clé du canal se trouve déjà dans l’ensemble de clés sélectionnées. Son jeu prêt à l’opération est donc modifié pour identifier les nouvelles opérations pour lesquelles le canal est signalé comme prêt. Toutes les informations de préparation précédemment enregistrées dans l’ensemble prêt sont conservées ; en d’autres termes, le jeu prêt retourné par le système sous-jacent est disjoint au niveau du bit dans le jeu prêt actuel de la clé.
</Li>
</ol>
Si toutes les clés de l’ensemble de clés au début de cette étape ont des ensembles d’intérêts vides, ni l’ensemble de clés sélectionnés ni les jeux d’opérations prêts pour les clés ne seront mis à jour.
<Li>
Si des clés ont été ajoutées à l’ensemble de clés annulées pendant que l’étape (2) était en cours, elles sont traitées comme à l’étape (1).
</Li>
</ol>
Si une opération de sélection bloque ou non l’attente d’un ou plusieurs canaux pour être prêt, et si c’est le cas pendant combien de temps, est la seule différence essentielle entre les trois méthodes de sélection.
<Opérations de sélection h3>qui effectuent une action sur les clés< sélectionnées/h3>
Pendant chaque opération de sélection, les clés peuvent être supprimées de la clé du sélecteur, de la clé sélectionnée et des jeux de clés annulés. La sélection est effectuée par les #select(Consumer)méthodes , #select(Consumer,long)et #selectNow(Consumer) implique trois étapes :
<ol>
<Li>
Chaque clé de l’ensemble de clés annulées est supprimée de chaque jeu de clés dont il est membre, et son canal est désinscrit. Cette étape laisse le jeu de clés annulée vide.
</Li>
<Li>
Le système d’exploitation sous-jacent est interrogé pour une mise à jour quant à la préparation de chaque canal restant pour effectuer l’une des opérations identifiées par l’ensemble d’intérêt de sa clé à partir du moment où l’opération de sélection a commencé.
Pour un canal prêt pour au moins une telle opération, le jeu d’opérations prêts de la clé du canal est défini pour identifier exactement les opérations pour lesquelles le canal est prêt et l’action spécifiée à la select méthode est appelée pour consommer la clé du canal. Toutes les informations de préparation précédemment enregistrées dans le jeu prêt sont ignorées avant d’appeler l’action.
Sinon, lorsqu’un canal est prêt pour plusieurs opérations, l’action peut être appelée plusieurs fois avec la clé du canal et le jeu d’opérations prêts modifiés sur un sous-ensemble des opérations pour lesquelles le canal est prêt. Lorsque l’action est appelée plusieurs fois pour la même clé, son jeu d’opérations prêt ne contient jamais les bits d’opération contenus dans l’ensemble aux appels précédents à l’action dans la même opération de sélection.
</Li>
<Li>
Si des clés ont été ajoutées à l’ensemble de clés annulées pendant que l’étape (2) était en cours, elles sont traitées comme à l’étape (1).
</Li>
</ol>
<h2>Concurrency</h2>
Un sélecteur et son jeu de clés sont sécurisés pour être utilisés par plusieurs threads simultanés. Toutefois, son jeu de clés sélectionné et son jeu de clés annulées ne le sont pas.
Les opérations de sélection se synchronisent sur le sélecteur lui-même, dans l’ensemble de clés sélectionnées, dans cet ordre. Ils se synchronisent également sur l’ensemble de clés annulées pendant les étapes (1) et (3) ci-dessus.
Les modifications apportées aux ensembles d’intérêt des clés d’un sélecteur pendant qu’une opération de sélection est en cours n’ont aucun effet sur cette opération ; ils seront vus par la prochaine opération de sélection.
Les clés peuvent être annulées et les canaux peuvent être fermés à tout moment. Par conséquent, la présence d’une clé dans un ou plusieurs ensembles de clés d’un sélecteur n’implique pas que la clé est valide ou que son canal est ouvert. Le code de l’application doit être prudent pour synchroniser et vérifier ces conditions si nécessaire s’il est possible qu’un autre thread annule une clé ou ferme un canal.
Un thread bloqué dans une opération de sélection peut être interrompu par un autre thread de l’une des trois manières suivantes :
<ul>
<Li>
En appelant la méthode du #wakeup wakeup sélecteur,
</Li>
<Li>
En appelant la méthode du #close close sélecteur ou
</Li>
<Li>
En appelant la méthode du java.lang.Thread#interrupt() interrupt thread bloqué, auquel cas son état d’interruption sera défini et la méthode du #wakeup wakeup sélecteur sera appelée.
</Li>
</ul>
La #close close méthode se synchronise sur le sélecteur et son jeu de clés sélectionnées dans le même ordre que dans une opération de sélection.
« ksc »>
L’ensemble de clés d’un sélecteur est sécurisé pour être utilisé par plusieurs threads simultanés. Les opérations de récupération à partir du jeu de clés ne bloquent généralement pas et peuvent donc chevaucher de nouvelles inscriptions qui ajoutent au jeu, ou avec les étapes d’annulation des opérations de sélection qui suppriment les clés du jeu. Les itérateurs et les séparateurs retournent des éléments reflétant l’état de l’ensemble à un moment donné ou depuis la création de l’itérateur/fractionneur. Ils ne lèvent java.util.ConcurrentModificationException ConcurrentModificationExceptionpas .
« sksc »>
L’ensemble de clés sélectionnées d’un sélecteur n’est pas, en général, sûr pour une utilisation par plusieurs threads simultanés. Si un tel thread peut modifier directement le jeu, l’accès doit être contrôlé en synchronisant sur le jeu lui-même. Les itérateurs retournés par les méthodes de java.util.Set#iterator() iterator l’ensemble sont rapides : si l’ensemble est modifié après la création de l’itérateur, à l’exception de l’appel de la propre java.util.Iterator#remove() remove méthode de l’itérateur, un java.util.ConcurrentModificationException itérateur est levée.
Ajouté dans la version 1.4.
Documentation Java pour java.nio.channels.Selector.
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.
Constructeurs
| Selector() |
Initialise une nouvelle instance de cette classe. |
| Selector(IntPtr, JniHandleOwnership) |
Constructeur utilisé lors de la création de représentations managées d’objets JNI ; appelée par le runtime. |
Propriétés
| Class |
Retourne la classe runtime de ce |
| Handle |
Handle de l’instance Android sous-jacente. (Hérité de Object) |
| IsOpen |
Indique si ce sélecteur est ouvert. |
| JniIdentityHashCode |
Multiplexeur d’objets |
| JniPeerMembers |
Multiplexeur d’objets |
| PeerReference |
Multiplexeur d’objets |
| ThresholdClass |
Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code. |
| ThresholdType |
Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code. |
Méthodes
| Clone() |
Crée et retourne une copie de cet objet. (Hérité de Object) |
| Close() |
Ferme ce sélecteur. |
| Dispose() |
Multiplexeur d’objets |
| Dispose(Boolean) |
Multiplexeur d’objets |
| Equals(Object) |
Indique si un autre objet est « égal à » celui-ci. (Hérité de Object) |
| GetHashCode() |
Retourne une valeur de code de hachage pour l'objet. (Hérité de Object) |
| JavaFinalize() |
Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet. (Hérité de Object) |
| Keys() |
Retourne le jeu de clés de ce sélecteur. |
| Notify() |
Réveille un thread unique qui attend le moniteur de cet objet. (Hérité de Object) |
| NotifyAll() |
Réveille tous les threads qui attendent le moniteur de cet objet. (Hérité de Object) |
| Open() |
Ouvre un sélecteur. |
| Provider() |
Retourne le fournisseur qui a créé ce canal. |
| Select() |
Sélectionne un ensemble de clés dont les canaux correspondants sont prêts pour les opérations d’E/S. |
| Select(IConsumer) |
Sélectionne et effectue une action sur les clés dont les canaux correspondants sont prêts pour les opérations d’E/S. |
| Select(IConsumer, Int64) |
Sélectionne et effectue une action sur les clés dont les canaux correspondants sont prêts pour les opérations d’E/S. |
| Select(Int64) |
Sélectionne un ensemble de clés dont les canaux correspondants sont prêts pour les opérations d’E/S. |
| SelectedKeys() |
Retourne le jeu de clés sélectionné de ce sélecteur. |
| SelectNow() |
Sélectionne un ensemble de clés dont les canaux correspondants sont prêts pour les opérations d’E/S. |
| SelectNow(IConsumer) |
Sélectionne et effectue une action sur les clés dont les canaux correspondants sont prêts pour les opérations d’E/S. |
| SetHandle(IntPtr, JniHandleOwnership) |
Définit la propriété Handle. (Hérité de Object) |
| ToArray<T>() |
Multiplexeur d’objets |
| ToString() |
Retourne une représentation de chaîne de l'objet. (Hérité de Object) |
| UnregisterFromRuntime() |
Multiplexeur d’objets |
| Wait() |
Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou><em>interrompu</em>.<> (Hérité de Object) |
| Wait(Int64) |
Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object) |
| Wait(Int64, Int32) |
Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object) |
| Wakeup() |
Provoque le retour immédiat de la première opération de sélection qui n’a pas encore été retournée. |
Implémentations d’interfaces explicites
| IJavaPeerable.Disposed() |
Multiplexeur d’objets |
| IJavaPeerable.DisposeUnlessReferenced() |
Multiplexeur d’objets |
| IJavaPeerable.Finalized() |
Multiplexeur d’objets |
| IJavaPeerable.JniManagedPeerState |
Multiplexeur d’objets |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Multiplexeur d’objets |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Multiplexeur d’objets |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Multiplexeur d’objets |
Méthodes d’extension
| JavaCast<TResult>(IJavaObject) |
Effectue une conversion de type vérifiée par le runtime Android. |
| JavaCast<TResult>(IJavaObject) |
Multiplexeur d’objets |
| GetJniTypeName(IJavaPeerable) |
Multiplexeur d’objets |