Process Builder waitFor () Les limites d'émission et ouvrir le fichier

Question

J'ai hérité du code:

Process p = new ProcessBuilder("/bin/chmod", "777", path).start();
p.waitFor();

En fait, il y a pour une raison ancienne et très voodoo base pour stocker des paires clé / valeur sur le disque sous forme de fichiers. Je ne veux pas vraiment aller en elle.

Cependant, je suis parti avec un tas d'exceptions IO:

Exception :Cannot run program "/bin/chmod": java.io.IOException: error=24, Too many open files
Message: Cannot run program "/bin/chmod": java.io.IOException: error=24, Too many open files

Et par un groupe que je veux dire dans les domaines de 10k - millions

Je reçois le sentiment que l'appel waitFor était d'arrêter ces de se produire en attendant la fin du processus et la sortie de retour, mais je pense que le chmod retourne un résultat avant que le fichier est effectivement fermé. Est-ce que quelqu'un sait si ce serait la cause de ces exceptions?

Mon autre tendance est que l'ouverture et la fermeture de milliers de fichiers ne se produit pas assez rapidement sur la fin de java et qu'il ya quelque chose d'autre se passe, peut-être quelque chose comme ça il y a une certaine forme de tampon de fichier qui ne reçoit pas éclairci quand fw.close () est appelée.

Je suis assez nouveau pour Java et ce fut un enfer bizarre qui m'a déconcerté. (Avec plaisir l'application fonctionne toujours en quelque sorte .. après avoir craché sur un fichier journal très grand qui est)

Quelqu'un d'autre peut penser à une façon de contourner ce problème, des tampons de compensation ou d'augmenter les fichiers de limite ouvert à quelque chose où la machine virtuelle Java peut rester avec lui-même (en supposant que le problème est)

Answer 1

Je suppose que vous exécutez ces commandes chmod dans une boucle - sinon je ne vois pas pourquoi vous obtiendriez tant d'exceptions. Il est possible que vous frappez une impasse parce que vous ne lisez pas la sortie des processus créés. Cela a certainement l'habitude de me mordre en retour dans la pré-ProcessBuilder, jours Runtime.exec().

Modifier l'extrait de code au motif ci-dessus:

try {
    ProcessBuilder pb = new ProcessBuilder("/bin/chmod", "777", path);    
    pb.redirectErrorStream(true); // merge stdout, stderr of process

    Process p = pb.start();
    InputStreamReader isr = new  InputStreamReader(p.getInputStream());
    BufferedReader br = new BufferedReader(isr);

    String lineRead;
    while ((lineRead = br.readLine()) != null) {
        // swallow the line, or print it out - System.out.println(lineRead);
    }

    int rc = p.waitFor();
    // TODO error handling for non-zero rc
}
catch (IOException e) {
    e.printStackTrace(); // or log it, or otherwise handle it
}
catch (InterruptedException ie) {
    ie.printStackTrace(); // or log it, or otherwise handle it
} 

(crédit: ce site ) et voir si cela aide la situation

Answer 2

Merci pour les gars d'aide, cela devrait régler une charge de bizarreries passe ailleurs à cause de cela.

Utilisation de votre (Vinay) par exemple et les fermetures de flux:

try{ 
  fw.close();

  ProcessBuilder pb = new ProcessBuilder("/bin/chmod", "777", path);

  pb.redirectErrorStream(true); // merge stdout, stderr of process
  p = pb.start();

  InputStreamReader isr = new  InputStreamReader(p.getInputStream());
  BufferedReader br = new BufferedReader(isr);

  String lineRead;
  while ((lineRead = br.readLine()) != null) {
    // swallow the line, or print it out - System.out.println(lineRead);
  }

} catch (Exception ioe) {
  Logger.logException(Logger.WARN, ioe.getMessage(), ioe);
} finally {
  try {
    p.waitFor();//here as there is some snipped code that was causing a different
                // exception which stopped it from getting processed

    //missing these was causing the mass amounts of open 'files'
    p.getInputStream().close();
    p.getOutputStream().close();
    p.getErrorStream().close(); 

  } catch (Exception ioe) {
    Logger.logException(Logger.WARN, ioe.getMessage(), ioe);
  }
}

a eu l'idée de John B Mathews après .

Answer 3

Il semble peu probable que le processus serait effectivement complet sans fermer les fichiers. Serait-ce qui se passe dans un très grand nombre de discussions? Ou peut-être certains d'entre eux ne terminent pas en fait (elle est suspendue à waitFor dans certains cas)?

Dans le cas contraire, je pense que vous serez coincé avec l'augmentation de la limite des fichiers ouverts. Si l'on suppose que c'est un système de type Unix, la commande « ulimit » est probablement ce que vous recherchez.

Answer 4

Si vous utilisez Java 6, vous pouvez également essayer les nouveaux setters (pour la lecture, écriture, exécution) sur l'objet fichier. Peut-être plus lent, mais il devrait fonctionner.