Est-il possible de lire à partir d'un InputStream avec un délai d'attente?

Plus précisément, le problème est d'écrire une méthode comme ceci:

int maybeRead(InputStream in, long timeout)

où la valeur de retour est la même que dans.read() si les données sont disponibles au sein de 'timeout' millisecondes, et 2 sinon. Avant le retour de la méthode, tout engendré fils doit quitter.

Pour éviter les disputes, le sujet ici java.io.InputStream, tel que documenté par le Soleil (n'importe quel version de Java). Veuillez noter que ce n'est pas aussi simple qu'il y paraît. Ci-dessous sont quelques-uns des faits qui sont pris en charge directement par le Soleil de la documentation.

  1. La dans.méthode read() peut être non-interruptible.

  2. Emballage de la InputStream dans un Lecteur ou InterruptibleChannel ne vous aide pas, parce que toutes les classes peuvent faire est d'appeler les méthodes de l'InputStream. S'il était possible d'utiliser ces classes, il serait possible d'écrire une solution qui ne fera qu'exécuter la même logique directement sur la InputStream.

  3. Il est toujours acceptable pour dans.disponible() renvoient 0.

  4. La dans.la méthode close() peut bloquer ou de ne rien faire.

  5. Il n'existe pas de façon de tuer un autre thread.

InformationsquelleAutor | 2009-04-30
  1. 77

    À l'aide de inputStream.disponible (en)

    Il est toujours acceptable pour le Système.dans.disponible() renvoient 0.

    J'ai trouvé le contraire - elle renvoie toujours la meilleure valeur pour le nombre d'octets disponibles. Javadoc pour InputStream.available():

    Returns an estimate of the number of bytes that can be read (or skipped over) 
from this input stream without blocking by the next invocation of a method for 
this input stream.

    Une estimation est inévitable en raison de la synchronisation/insipidité. Le chiffre peut être une sous-estimer parce que de nouvelles données arrivent constamment. Cependant il toujours "rattrape" sur le prochain appel - il doit tenir compte de tous arrivés de données, d'un bar qui arrivent juste au moment du nouvel appel. Définitivement de retour 0 quand il y a des données ne sont pas la condition ci-dessus.

    Première mise en garde: Béton sous-classes de InputStream sont responsables de disponible()

    InputStream est une classe abstraite. Il n'a pas de source de données. C'est vide de sens pour elle d'avoir à disposition des données. Par conséquent, javadoc pour available() déclare également:

    The available method for class InputStream always returns 0.

This method should be overridden by subclasses.

    Et en effet, le béton flux d'entrée des classes de faire remplacer disponibles(), en fournissant des valeurs significatives, pas de constante 0.

    Deuxième mise en garde: assurez-vous d'utiliser le transport-retour lors de la saisie dans Windows.

    Si vous utilisez System.in, votre programme ne reçoit les commentaires lors de votre commande shell mains il. Si vous utilisez un fichier de redirection/tuyaux (par exemple unfichier > java myJavaApp ou somecommand | java myJavaApp ), puis les données d'entrée sont généralement remis immédiatement. Toutefois, si vous avez manuellement le type d'entrée, les données de transfert peut être retardée. E. g. Avec windows cmd.exe shell, les données sont mises en mémoire tampon à l'intérieur de cmd.exe shell. Les données ne sont transmises à l'exécution de java le programme de retour de chariot (control-m ou <enter>). C'est une limitation de l'environnement d'exécution. Bien sûr, InputStream.disponible() renvoie 0 pour aussi longtemps que le shell en mémoire tampon les données, c'est le comportement correct; il n'y a pas de données disponibles à ce point. Dès que les données sont disponibles à partir de la coquille, la méthode renvoie une valeur > 0. NB: utilise Cygwin cmd.exe trop.

    Solution la plus simple (pas de blocage, donc pas de délai d'attente requis)

    Utiliser seulement ceci:

        byte[] inputData = new byte[1024];
    int result = is.read(inputData, 0, is.available());  
    //result will indicate number of bytes read; -1 for EOF with no data read.

    OU, de manière équivalente,

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in, Charset.forName("ISO-8859-1")),1024);
    //...
         //inside some iteration /processing logic:
         if (br.ready()) {
             int readCount = br.read(inputData, bufferOffset, inputData.length-bufferOffset);
         }

    Solution plus riche (au maximum remplit tampon à l'intérieur de délai d'attente)

    Déclarer ceci:

    public static int readInputStreamWithTimeout(InputStream is, byte[] b, int timeoutMillis)
     throws IOException  {
     int bufferOffset = 0;
     long maxTimeMillis = System.currentTimeMillis() + timeoutMillis;
     while (System.currentTimeMillis() < maxTimeMillis && bufferOffset < b.length) {
         int readLength = java.lang.Math.min(is.available(),b.length-bufferOffset);
         //can alternatively use bufferedReader, guarded by isReady():
         int readResult = is.read(b, bufferOffset, readLength);
         if (readResult == -1) break;
         bufferOffset += readResult;
     }
     return bufferOffset;
 }

    Puis utilisez ceci:

        byte[] inputData = new byte[1024];
    int readCount = readInputStreamWithTimeout(System.in, inputData, 6000);  //6 second timeout
    //readCount will indicate number of bytes read; -1 for EOF with no data read.
    • J'ai aimé cette réponse
    • +1, une Bien meilleure réponse que l'on a accepté un.
    • Si is.available() > 1024 cette suggestion sera un échec. Il y a certainement des flux qui ne retournent pas de zéro. SSLSockets par exemple, jusqu'à récemment. Vous ne pouvez pas compter sur cela.
    • Le cas 'est.disponible() > 1024' est spécifiquement traitée par readLength.
    • Commentaire re SSLSockets incorrects, il renvoie 0 pour disponible le forum il n'y a pas de données dans la mémoire tampon. Comme par ma réponse. Javadoc: "Si il n'y a pas d'octets mise en mémoire tampon sur le support et le support n'a pas été fermée à l'aide de près, puis disponible sera de retour 0. "
    • Mon commentaire re SSLSocket n'est pas incorrect. Jusqu'à récemment, [je souligne] il a utilisé pour revenir à zéro à tout moment. Vous parlez de la présente. Je parle de toute l'histoire de la JSSE, et j'ai travaillé depuis avant il a d'abord été inclus dans la Java 1.4 en 2002.
    • Par la modification de la boucle while conditions, "tout (est.disponible() > 0 && Système.currentTimeMillis() < maxTimeMillis && bufferOffset < b.la longueur) {" m'a sauvé une tonne de surcharge du PROCESSEUR.
    • C'est votre évaluation que "jusqu'à récemment," les flux d'entrée à partir d'un SSLSocket violé le contrat de disponible()? Ou était le contrat de InputStream changé et SSLSocket a été mis à jour en conséquence?
    • C'est mon expérience au cours de nombreuses années que SSLSocket.getInputStream().available() retourné à zéro; nulle part ai-je affirmé que cette " violé le contrat de available()'; nulle part je n'ai affirmé que "le contrat de InputStream changé": ce sont tous vos affirmations; pas de mine.
    • J'ai dit "d'évaluation" non "affirmation". Mais permettez-moi de reformuler. Glen Meilleur de la réponse explique pourquoi "de façon Permanente à un retour de zéro" serait une violation du contrat (JavaDoc) de mise en place de disponible (), à moins que l'inputstream ne pourrait jamais recevoir d'entrée. Mais vous avez déclaré que "jusqu'à récemment," les flux d'entrées retournées par SSLSocket est "retour à zéro à tout moment". Cela viole le contrat actuel. A le contrat pour la disposition() différents? Ou était SSLSocket retour d'un InputStream qui viole le contrat? Aussi, savez-vous en quelle version de Java, ce qui a changé? Merci
    • disponible (en) est un blocage de la méthode la moins fiable comme indiqué dans les docs
    • Bien que j'ai aimé cette réponse (et d'utiliser une version légèrement modifiée), un problème avec ceci est que l'entrée ne s'affiche dans la console (cmd.exe) après avoir appuyé sur la touche Entrée.
    • Ce n'est effectivement pas une bonne réponse. 1) comme déjà indiqué, disponible() peut retourner 0, en fonction de la JVM, la version de l'OS, les mises en œuvre. 2) Si vous tentez d'accéder erronée fichiers à tout lire() l'appel ne peut jamais revenir (ou du moins pas dans un délai décent, certains sont à 10 minutes). Donc, en utilisant cette solution est une mauvaise idée. Ian Jones réponse est beaucoup mieux et mieux lisible s'il est correctement écrit.

    InformationsquelleAutor Glen Best
  2. 64

    En supposant que le flux n'est pas soutenu par une prise (de sorte que vous ne pouvez pas utiliser Socket.setSoTimeout()), je pense que le niveau moyen de résoudre ce type de problème est d'utiliser un Avenir.

    Supposons que j'ai la suite exécuteur testamentaire et de ruisseaux:

        ExecutorService executor = Executors.newFixedThreadPool(2);
    final PipedOutputStream outputStream = new PipedOutputStream();
    final PipedInputStream inputStream = new PipedInputStream(outputStream);

    J'ai un écrivain qui écrit des données puis attend 5 secondes avant d'écrire le dernier morceau de données et la fermeture du flux:

        Runnable writeTask = new Runnable() {
        @Override
        public void run() {
            try {
                outputStream.write(1);
                outputStream.write(2);
                Thread.sleep(5000);
                outputStream.write(3);
                outputStream.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    };
    executor.submit(writeTask);

    La façon normale de lecture se présente comme suit. La lecture de bloquer indéfiniment pour des données et ainsi ce termine dans 5s:

        long start = currentTimeMillis();
    int readByte = 1;
    //Read data without timeout
    while (readByte >= 0) {
        readByte = inputStream.read();
        if (readByte >= 0)
            System.out.println("Read: " + readByte);
    }
    System.out.println("Complete in " + (currentTimeMillis() - start) + "ms");

    sorties:

    Read: 1
Read: 2
Read: 3
Complete in 5001ms

    Si il y a un problème plus fondamental, comme l'écrivain ne répond pas, le lecteur devrait bloquer pour toujours.
    Si j'enveloppe le lire dans un avenir, je peux contrôler le délai d'attente comme suit:

        int readByte = 1;
    //Read data with timeout
    Callable<Integer> readTask = new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            return inputStream.read();
        }
    };
    while (readByte >= 0) {
        Future<Integer> future = executor.submit(readTask);
        readByte = future.get(1000, TimeUnit.MILLISECONDS);
        if (readByte >= 0)
            System.out.println("Read: " + readByte);
    }

    sorties:

    Read: 1
Read: 2
Exception in thread "main" java.util.concurrent.TimeoutException
    at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:228)
    at java.util.concurrent.FutureTask.get(FutureTask.java:91)
    at test.InputStreamWithTimeoutTest.main(InputStreamWithTimeoutTest.java:74)

    Je peux attraper le TimeoutException et faire tout le nettoyage je veux.

    • +1 pour me dire sur la façon d'utiliser Java Avenir!
    • Jones Très intéressant, merci
    • Mais ce que le blocage du thread ?! Il va rester dans la mémoire jusqu'à l'application se termine ? Si je suis correct, cela peut produire des fils sans fin l'application est très chargée et même plus, bloquer d'autres threads à l'aide de votre piscine qui a son fils occupé et bloqué. S'il vous plaît corrigez-moi si je me trompe. Je vous remercie.
    • Muhammad Gelbana, vous avez raison: le blocage read() thread reste en cours d'exécution et qui n'est pas OK. J'ai trouvé un moyen pour éviter cela: lorsque l'heure de hits, près du thread appelant le flux d'entrée (dans mon cas, j'ai fermer la android bluetooth prise à partir de laquelle les flux d'entrée vient). Lorsque vous faites cela, la lecture() va retourner immédiatement.. Bien que dans mon cas, j'utilise l'int read(byte[]) surcharge, et que l'on retourne immédiatement. Peut-être l'int read() à une surcharge de jeter un IOException car je ne sais pas ce qu'il serait de retour... À mon avis c'est la bonne solution.
    • -1 comme les threads de lecture reste bloqué jusqu'à ce que l'application se termine.
    • C'est un peu ce que je voulais dire par "attraper le TimeoutException et faire tout le nettoyage..." Par exemple que je veuille tuer le thread de lecture: ... catch (TimeoutException e) { exécuteur testamentaire.shutdownNow(); }
    • executer.shutdownNow ne tuera pas le fil. Il va essayer de l'interrompre, sans aucun effet. Il n'y a pas de nettoyage possible et c'est un problème sérieux.
    • Si vous voulez tuer le thread, la meilleure chose à faire est de fermer le flux d'entrée après la capture de la TimeoutException.
    • Devrait utiliser des tampons d'e/S de java mains de cette tâche à l'O/S pour des performances élevées. Les threads Java gestion octet-par-octet, sont inefficaces. Si vous appliquez la mise en mémoire tampon, votre méthode ne gère pas ce scénario: i) de la mémoire tampon vide ii) 2 second délai d'attente iii) 50% de la mémoire tampon complète dans un délai de 2 sec iv) voulez lire & retour à la 50% & ne pas attendre pour 100% de remplissage de la mémoire tampon. c'est à dire que Nous avons toujours avoir une boucle autour des appels à maybeRead(InputStream, long délai d'attente).
    • Vous pouvez prendre du champ avec le tampon et le remplir. Si le Délai se produisent, vous pouvez lire toute l'info de tampon, s'il est présent ici. Voir le code de readLine() et de faire un code similaire mais à l'intérieur de call() de Future.

    InformationsquelleAutor Ian Jones
  3. 18

    Je m'interroge sur l'énoncé du problème plutôt que de simplement l'accepter aveuglément. Vous avez seulement besoin de délais d'attente à partir de la console ou sur le réseau. Si le dernier vous avez Socket.setSoTimeout() et HttpURLConnection.setReadTimeout() qui à la fois faire exactement ce qui est nécessaire, aussi longtemps que vous les configurer correctement lors de la construction/acquisition. Laisser à l'arbitraire d'un point plus tard dans l'application lorsque tout ce que vous avez est le InputStream est une mauvaise conception menant à un très maladroit de mise en œuvre.

    • Il existe d'autres situations où une lecture pourrait potentiellement bloquer pour un temps significatif; par exemple, lors de la lecture d'un lecteur de bande, à partir d'un montage à distance de lecteur réseau ou à partir d'un HFS avec une bande de robot à la fin. (Mais l'axe principal de votre réponse est juste.)
    • pour vos commentaires et exemples. Pour ajouter plus de votre exemple, un simple cas où les connexions socket a été fait correctement mais lire tentative a été bloqué tant que les données devaient être récupérées à partir de DB, mais de toute façon il n'a pas eu lieu (permet de " dire DB n'était pas de répondre à la requête et est allé dans l'état Verrouillé). Dans ce scénario, vous devez disposer d'un moyen explicitement délai d'attente de l'opération de lecture sur la socket.
    • Ce cas est déjà couvert par ma réponse.
    • Le point de l'ensemble de l'InputStream abstraction est de ne pas penser à propos de l'implémentation sous-jacente. Ses juste pour argumenter sur les avantages et les inconvénients des réponses. Mais, à la question de l'énoncé du problème, ne va pas aider la disussion
    • Le point de l'ensemble de la InputStream est de ne pas disposer d'un délai d'attente de la méthode, ni la plupart des implémentations sous-jacentes. Sockets sont une exception remarquable et le seul que je peux penser à de la main gauche. Ignorant les faits ne va pas aider à la discussion.
    • InputStream travaux sur un cours d'eau et il bloque, mais il ne fournit pas un mécanisme d'expiration. Si l'InputStream l'abstraction n'est pas un bien conçu abstraction. Par conséquent demandé un moyen de timeout sur un stream n'est pas en train de demander beaucoup. La question est donc de demander une solution à un problème très concret. La plupart des implémentations sous-jacentes va bloquer. C'est l'essence même d'un ruisseau. Sockets, des Fichiers, des Tuyaux de bloc si l'autre côté du cours d'eau n'est pas prête à de nouvelles données.
    • Vous convenez donc avec moi en s'interrogeant sur l'énoncé du problème.
    • Je ne sais pas comment vous l'avez compris. Je n'étais pas d'accord avec vous. L'énoncé du problème "comment" timeout "sur un InputStream" est valide. Car le cadre ne fournit pas un moyen de délai d'attente, il est approprié de poser une telle question.
    • C'est une terrible réponse. Il n'y a pas besoin de la question de l'énoncé du problème'. Un exemple: L'Android BluetoothSocket n'a aucun moyen de définir un délai d'attente et ne présente un InputStream plus de son API. Il va heureusement bloquer à jamais sur un read(). Mais, selon cette réponse, chaque Application est "mal conçu". (Je serais heureux de convenir que l'Android BT cadre est mal conçu, cependant)
    • C'est un terrible commentaire. Vous avez mal lu la réponse. Toute application qui laisse réglage du délai d'attente à un point arbitraire dans l'application où tous les il a est un flux d'entrée est mal conçu. Comme il n'y a pas de telles applications, sauf pour celui-ci, parce qu'ils ne peuvent pas être écrits de cette façon, que signifie exactement une application. Le délai d'expiration doit en effet être fixé sur le support, pas le flux d'entrée, et c'est ce qu'il dit dans ma réponse, et ce qui est mal avec la question, et l'énoncé du problème.
    • que faire si le setSoTimeout est insuffisante, ce qui semble être le cas dans cette question: stackoverflow.com/questions/50721594/...
    • La question n'est pas vraiment dire quelque chose comme indiqué. Si setSoTimeout() n'est pas suffisant, ce serait? Et NB de votre affirmation dans cette question qu'il ne fonctionne pas pour les sockets client n'est pas correct.
    • Que vous avez seulement besoin de délais d'attente lors de la lecture à partir de la console ou des prises n'est pas vrai. Il y a des situations où vous avez besoin de délais d'attente lors de la lecture de tuyaux ou de suivi des fichiers.

    InformationsquelleAutor user207421
  4. 18

    Si votre InputStream est soutenu par un support, vous pouvez définir un Socket délai d'attente (en millisecondes) à l'aide de setSoTimeout. Si la lecture() l'appel n'a pas débloquer dans le délai spécifié, il va lancer une SocketTimeoutException.

    Assurez-vous juste que vous appelez setSoTimeout sur le support avant de le lire() de l'appel.

    InformationsquelleAutor Templar
  5. 7

    Je n'ai pas utilisé les classes de Java NIO paquet, mais il semble ils pourraient être d'une aide ici. Plus précisément, java.nio.les canaux.Canaux et java.nio.les canaux.InterruptibleChannel.

    • +1: je ne crois pas qu'il y est un moyen fiable pour faire ce que l'OP demande avec InputStream seul. Cependant, nio a été créé à cette fin, entre autres.
    • L'OP a déjà fondamentalement exclue. InputStreams sont, de nature, de blocage et peut-être non-interruptible.
    InformationsquelleAutor jt.
  6. 5

    Ici est un moyen d'obtenir une NIO FileChannel à partir du Système.dans et de vérifier la disponibilité de données à l'aide d'un délai d'attente, ce qui est un cas particulier du problème décrit dans la question. Exécuter à la console, ce n'est pas le type de l'entrée, et attendre les résultats. Il a été testé avec succès sous Java 6 sur Windows et Linux.

    import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedByInterruptException;
public class Main {
static final ByteBuffer buf = ByteBuffer.allocate(4096);
public static void main(String[] args) {
long timeout = 1000 * 5;
try {
InputStream in = extract(System.in);
if (! (in instanceof FileInputStream))
throw new RuntimeException(
"Could not extract a FileInputStream from STDIN.");
try {
int ret = maybeAvailable((FileInputStream)in, timeout);
System.out.println(
Integer.toString(ret) + " bytes were read.");
} finally {
in.close();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/* unravels all layers of FilterInputStream wrappers to get to the
* core InputStream
*/
public static InputStream extract(InputStream in)
throws NoSuchFieldException, IllegalAccessException {
Field f = FilterInputStream.class.getDeclaredField("in");
f.setAccessible(true);
while( in instanceof FilterInputStream )
in = (InputStream)f.get((FilterInputStream)in);
return in;
}
/* Returns the number of bytes which could be read from the stream,
* timing out after the specified number of milliseconds.
* Returns 0 on timeout (because no bytes could be read)
* and -1 for end of stream.
*/
public static int maybeAvailable(final FileInputStream in, long timeout)
throws IOException, InterruptedException {
final int[] dataReady = {0};
final IOException[] maybeException = {null};
final Thread reader = new Thread() {
public void run() {                
try {
dataReady[0] = in.getChannel().read(buf);
} catch (ClosedByInterruptException e) {
System.err.println("Reader interrupted.");
} catch (IOException e) {
maybeException[0] = e;
}
}
};
Thread interruptor = new Thread() {
public void run() {
reader.interrupt();
}
};
reader.start();
for(;;) {
reader.join(timeout);
if (!reader.isAlive())
break;
interruptor.start();
interruptor.join(1000);
reader.join(1000);
if (!reader.isAlive())
break;
System.err.println("We're hung");
System.exit(1);
}
if ( maybeException[0] != null )
throw maybeException[0];
return dataReady[0];
}
}

    Il est intéressant de noter, lors de l'exécution du programme à l'intérieur de NetBeans 6.5 plutôt qu'à la console, le délai d'attente ne fonctionne pas du tout, et l'appel Système.exit() est en fait nécessaire de tuer le zombie threads. Ce qui se passe est que le interruptor thread se bloque (!) sur l'appel au lecteur.interrupt(). Un autre programme de test (non montré ici) en outre, essaie de fermer le canal, mais même cela ne fonctionne pas.

    • ne fonctionne pas sur mac os, ni avec JDK 1.6, ni avec JDK 1.7. L'interruption est reconnu seulement après avoir appuyé sur le retour au cours de la lecture.
    InformationsquelleAutor
  7. 4

    Que jt a dit, NIO est le meilleur (et corriger) solution. Si vous êtes vraiment coincé avec un InputStream cependant, vous pouvez soit

    1. Frayer un thread qui est exclusive de l'emploi est à lire à partir de l'InputStream et mettre le résultat dans une mémoire tampon qui peut être lu à partir de votre fil d'origine sans blocage. Cela devrait bien fonctionner si vous ne jamais avoir qu'une seule instance du flux. Sinon, vous pourriez être en mesure de tuer le thread à l'aide de l'obsolète méthodes de la classe Thread, même si cela peut causer des fuites de ressource.

    2. Compter sur isAvailable pour indiquer que les données qui peuvent être lues sans blocage. Toutefois, dans certains cas (comme avec les Sockets), il peut prendre un potentiellement bloquant lire pour isAvailable rapport à quelque chose d'autre que 0.

    • Socket.setSoTimeout() est tout aussi correct et beaucoup plus simple solution. Ou HttpURLConnection.setReadTimeout().
    • ce ne sont que des "bon" dans certaines circonstances; par exemple, si le flux d'entrée est un socket stream / connexion HTTP flux.
    • C NIO n'est non bloquant et sélectionnable dans les mêmes circonstances. Il n'y a pas de non-blocage des e/S de fichier par exemple.
    • mais il y a des non-blocage de tuyau d'e / s (Système d'.dans l'), non-blocage I/O pour les fichiers (sur le disque local) est un non-sens
    • Système.en est ni le non-blocage, ni d'un tuyau. Je suis d'accord avec votre dernière phrase, c'est pourquoi je l'ai dit.
    • Sur la plupart (tous?) Unix Système.en est en fait un pipe (si vous ne le dites pas à shell pour le remplacer par le fichier) et comme un tuyau, il peut être non-bloquant.
    • Système.en Java est InputStream, qui n'est ni sans blocage ni une pipe. Si fd 0 se trouve être d'une pipe, il peut être obtenu via le Système.inheritedChannel (), mais qui n'a rien à voir avec le Système.dans.
    • Arguant de ce que InputStream n'est pas de la plaine BS depuis qu'elle est abstraite de la superclasse. InputStream en fait PEUT être un tuyau (d'où la non-bloquant) et 99% du temps du Système.dans une pipe. Je peux faire JNI code qui obtient fd à partir du Système.et de faire le non-blocage IO sans problème. Mais je ne peux pas le faire via l'API Java (inheritedChanel() ne retourne pas SelectableChannel). Blâmer NIO décideurs. Et de toute façon, il n'y a pas une telle chose comme C NIO ;).
    • Vous êtes juste de perdre du temps. (1) Un InputStream ne peut pas être non-bloquant, en toutes circonstances, indépendamment de ce que la classe de béton est de l'étendre. (2) L'entrée standard est principalement un terminal, parfois, un fichier, parfois un tuyau. 99% de ce dernier est très incorrect. (3) C NIO est un leurre que vous avez introduites, comme en (4) la demande de ce Système.dans est non bloquant le canal d'e/S, ce qui reste faux.
    • Plus timewasting. (1) et (2): socket canaux et terminaux peuvent en effet être mis en mode sans blocage , et (1) peut être réalisée en Java: comme je n'ai jamais dit le contraire, votre point m'échappe. (3) "Stephen C NIO' contient une partie de Stephen C est le nom de l'affiche, je ne fait que répondre aux. Le point de votre (4) m'échappe également qu'il ne soit pas en contradiction avec tout ce que j'ai dit. Pour le reste, vous avez encore besoin d'arrêter la confusion de l'héritage Unix fd=0, un FD, avec un Système.dans un InputStream, qui ne peut être mis en mode sans blocage. Période. Ligne 264 du code que vous citez utilise un FD pas un InputStream.

    InformationsquelleAutor