Comment lire depuis l'entrée standard non bloquante?

    long end=System.currentTimeMillis()+60*10;
    InputStreamReader fileInputStream=new InputStreamReader(System.in);
    BufferedReader bufferedReader=new BufferedReader(fileInputStream);
    try
    {
        while((System.currentTimeMillis()<end) && (bufferedReader.readLine()!=null))
        {

        }
        bufferedReader.close();
    }
    catch(java.io.IOException e)
    {
        e.printStackTrace();
    }

J'ai effectivement essayé de faire de la ci-dessus pour la lecture à 600 millisecondes de temps après laquelle il ne devrait pas autoriser la lecture, mais la readline de la bufferedreader est bloquant.S'il vous plaît aider

source d'informationauteur pavi

  1. 2

    Vous pourriez vérifier avec BufferedReader.() > 0 si il y a des caractères à lire.

    String s;

while((System.currentTimeMillis()<end))
{
    if (bufferedReader.available() > 0)
        s += bufferedReader.readLine();
}

bufferedReader.close();
  2. 7

    À l'aide de BufferedReader.available() comme suggéré par Sibbo n'est pas fiable. La Documentation de available() états:

    Retourne une estimation le nombre d'octets qui peut être lu... Il n'est jamais correct d'utiliser la valeur de retour de cette méthode pour allouer un tampon.

    En d'autres termes, vous ne pouvez pas compter sur cette valeur, par exemple, il peut renvoyer 0 même si certains personnages sont effectivement disponibles.

    J'ai fait quelques recherches et à moins que vous sont en mesure de fermer les processus de flux d'entrée de l'extérieur, vous avez besoin de recourir à une lecture asynchrone à partir d'un autre thread. Vous pouvez trouver un exemple sur la façon de lire sans blocage, ligne par ligne,ici.

    Mise à jour: Voici une version simplifiée du code à partir du lien ci-dessus:

    public class NonblockingBufferedReader {
private final BlockingQueue<String> lines = new LinkedBlockingQueue<String>();
private volatile boolean closed = false;
private Thread backgroundReaderThread = null;
public NonblockingBufferedReader(final BufferedReader bufferedReader) {
backgroundReaderThread = new Thread(new Runnable() {
@Override
public void run() {
try {
while (!Thread.interrupted()) {
String line = bufferedReader.readLine();
if (line == null) {
break;
}
lines.add(line);
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
closed = true;
}
}
});
backgroundReaderThread.setDaemon(true);
backgroundReaderThread.start();
}
public String readLine() throws IOException {
try {
return closed && lines.isEmpty() ? null : lines.poll(500L, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
throw new IOException("The BackgroundReaderThread was interrupted!", e);
}
}
public void close() {
if (backgroundReaderThread != null) {
backgroundReaderThread.interrupt();
backgroundReaderThread = null;
}
}
}
  3. 2
    long end=System.currentTimeMillis()+60*10;
InputStreamReader fileInputStream = new InputStreamReader(System.in);
BufferedReader bufferedReader = new BufferedReader(fileInputStream);
try {
while ((System.currentTimeMillis() < end)) {
if (bufferedReader.ready()) {
System.out.println(bufferedReader.readLine());
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (bufferedReader != null) {
bufferedReader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
  4. 0

    BufferReader.readLine() peut se bloquer pour un temps très long si une ligne est très long comme 1M caractères.

    Votre fichier contient de longues lignes?

    Si oui, vous pouvez avoir à briser les lignes, ou de l'utilisation par char méthodes de lecture comme BufferReader.read().

  5. 0

    Le seul moyen serait de démarrer un thread de travail et de faire la lecture à l'intérieur, tandis que le thread appelant à surveiller le temps de latence.

    Si le thread est en attente est plus que permis, le maître thread de le résilier et de lever une exception.