Diferença entre ProcessBuilder e Runtime.exec ()

Estou tentando executar um comando externo de código java, mas há uma diferença que notei entre Runtime.getRuntime().exec(...)e new ProcessBuilder(...).start().

Ao usar Runtime:

Process p = Runtime.getRuntime().exec(installation_path + 
                                       uninstall_path + 
                                       uninstall_command + 
                                       uninstall_arguments);
p.waitFor();

o exitValue é 0 e o comando é encerrado ok.

No entanto, com ProcessBuilder:

Process p = (new ProcessBuilder(installation_path +    
                                 uninstall_path +
                                 uninstall_command,
                                 uninstall_arguments)).start();
p.waitFor();

o valor de saída é 1001 e o comando termina no meio, embora waitForretorne.

O que devo fazer para corrigir o problema ProcessBuilder?

As várias sobrecargas de Runtime.getRuntime().exec(...)levam uma matriz de strings ou uma única string. As sobrecargas de string única de exec()irão transformar a string em uma matriz de argumentos, antes de passar a matriz de string para uma das exec()sobrecargas que recebe uma matriz de string. Os ProcessBuilderconstrutores, por outro lado, usam apenas um array varargs de strings ou um Listde strings, em que cada string no array ou lista é considerado um argumento individual. De qualquer forma, os argumentos obtidos são então reunidos em uma string que é passada ao sistema operacional para execução.

Então, por exemplo, no Windows,

Runtime.getRuntime().exec("C:\DoStuff.exe -arg1 -arg2");

irá executar um DoStuff.exeprograma com os dois argumentos fornecidos. Nesse caso, a linha de comando é convertida em tokens e recomposta. Contudo,

ProcessBuilder b = new ProcessBuilder("C:\DoStuff.exe -arg1 -arg2");

irá falhar, a menos que haja um programa cujo nome esteja DoStuff.exe -arg1 -arg2em C:\. Isso ocorre porque não há tokenização: presume-se que o comando a ser executado já tenha sido tokenizado. Em vez disso, você deve usar

ProcessBuilder b = new ProcessBuilder("C:\DoStuff.exe", "-arg1", "-arg2");

ou alternativamente

List<String> params = java.util.Arrays.asList("C:\DoStuff.exe", "-arg1", "-arg2");
ProcessBuilder b = new ProcessBuilder(params);

Veja como Runtime.getRuntime().exec()passa o comando String para o ProcessBuilder. Ele usa um tokenizer e explode o comando em tokens individuais e, em seguida, invoca exec(String[] cmdarray, ......)que constrói um ProcessBuilder.

Se você construir o ProcessBuildercom uma matriz de strings em vez de uma única, obterá o mesmo resultado.

O ProcessBuilderconstrutor recebe um String...vararg, portanto, passar o comando inteiro como uma única String tem o mesmo efeito que invocar esse comando entre aspas em um terminal:

shell$ "command with args"

Não há diferença entre ProcessBuilder.start()e Runtime.exec()porque a implementação de Runtime.exec()é:

public Process exec(String command) throws IOException {
    return exec(command, null, null);
}

public Process exec(String command, String[] envp, File dir)
    throws IOException {
    if (command.length() == 0)
        throw new IllegalArgumentException("Empty command");

    StringTokenizer st = new StringTokenizer(command);
    String[] cmdarray = new String[st.countTokens()];
    for (int i = 0; st.hasMoreTokens(); i++)
        cmdarray[i] = st.nextToken();
    return exec(cmdarray, envp, dir);
}

public Process exec(String[] cmdarray, String[] envp, File dir)
    throws IOException {
    return new ProcessBuilder(cmdarray)
        .environment(envp)
        .directory(dir)
        .start();
}

Então codifique:

List<String> list = new ArrayList<>();
new StringTokenizer(command)
.asIterator()
.forEachRemaining(str -> list.add((String) str));
new ProcessBuilder(String[])list.toArray())
            .environment(envp)
            .directory(dir)
            .start();

deve ser o mesmo que:

Runtime.exec(command)

Obrigado dave_thompson_085 pelo comentário

Sim, há uma diferença.

• O Runtime.exec(String)método usa uma única string de comando que é dividida em um comando e uma sequência de argumentos.

• O ProcessBuilderconstrutor leva um (varargs) array de strings. A primeira string é o nome do comando e o restante são os argumentos. (Há um construtor alternativo que leva uma lista de strings, mas nenhum que leva uma única string consistindo no comando e nos argumentos.)

Então, o que você está dizendo ao ProcessBuilder para fazer é executar um "comando" cujo nome contém espaços e outras coisas inúteis. Obviamente, o sistema operacional não consegue encontrar um comando com esse nome e a execução do comando falha.