Ich habe ein Problem, bei dem ich in einem Java / Groovy-Programm die Grenzwerte für das Öffnen von Dateien unter Linux herausfinden muss. Wenn ich ulimit vom Terminal aus ausführe, werden separate Werte für die Grenzwerte für geöffnete und nicht geöffnete Dateien angegeben.

$ ulimit -n
1024
$ ulimit -Hn
4096

Wenn ich es jedoch in Groovy ausführe, ignoriert es die weiche Grenze und gibt immer einen harten Grenzwert zurück.

groovy> ['bash', '-c', 'ulimit -n'].execute().text  
Result: 4096

groovy> ['bash', '-c', 'ulimit -Hn'].execute().text 
Result: 4096

Bitte lassen Sie mich wissen, wenn ich etwas vermisse. Ich habe Ubuntu 12.04, Groovy Version: 1.8.4 JVM: 1.6.0_29 für diese Ausführung verwendet.

Aktualisieren: Ich habe dasselbe in Java versucht.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;

public class LinuxInteractor {
    public static int executeCommand(String command, boolean waitForResponse, OutputHandler handler) {
        int shellExitStatus = -1;
        ProcessBuilder pb = new ProcessBuilder("bash", "-c", command);
        pb.redirectErrorStream(true);
        try {
            Process shell = pb.start();

            if (waitForResponse) {

                // To capture output from the shell
                InputStream shellIn = shell.getInputStream();

                // Wait for the shell to finish and get the return code
                shellExitStatus = shell.waitFor();

                convertStreamToStr(shellIn, handler);
                shellIn.close();
            }
        }

        catch (IOException e) {
            System.out
                    .println("Error occured while executing Linux command. Error Description: "
                            + e.getMessage());
        }
        catch (InterruptedException e) {
            System.out
                    .println("Error occured while executing Linux command. Error Description: "
                            + e.getMessage());
        }
        return shellExitStatus;
    }

    public static String convertStreamToStr(InputStream is, OutputHandler handler) throws IOException {

        if (is != null) {
            Writer writer = new StringWriter();

            char[] buffer = new char[1024];
            try {
                Reader reader = new BufferedReader(new InputStreamReader(is,
                        "UTF-8"));
                int n;
                while ((n = reader.read(buffer)) != -1) {
                    String output = new String(buffer, 0, n);
                    writer.write(buffer, 0, n);

                    if(handler != null)
                        handler.execute(output);
                }
            } finally {
                is.close();
            }
            return writer.toString();
        } else {
            return "";
        }
    }

    public abstract static class OutputHandler {
        public abstract void execute(String str);
    }

    public static void main(String[] args) {
        OutputHandler handler = new OutputHandler() {
            @Override
            public void execute(String str) {
                System.out.println(str);
            }
        };

        System.out.print("ulimit -n : ");
        LinuxInteractor.executeCommand("ulimit -n", true, handler);
        System.out.print("ulimit -Hn : ");
        LinuxInteractor.executeCommand("ulimit -Hn", true, handler);
    }

}

Ausgabe für dieses Programm:

$ java LinuxInteractor 
ulimit -n : 4096

ulimit -Hn : 4096

Warum ist das Verhalten in Java gleich? Ist Java-Einstellung ulimit zufällig. Danke im Voraus.