如何關閉來自java.lang.Process的std-streams？

Question

這個問題是關於java.lang.Process及其對stdin，stdout和stderr的處理。

我們在我們的項目中有一個班級，是org.apache.commons.io.IOUtils的擴展。在那裏，我們有一個安靜的新方法來關閉Process-Object的std-streams適當的？還是不適合？

/** 
* Method closes all underlying streams from the given Process object. 
* If Exit-Code is not equal to 0 then Process will be destroyed after 
* closing the streams. 
* 
* It is guaranteed that everything possible is done to release resources 
* even when Throwables are thrown in between. 
* 
* In case of occurances of multiple Throwables then the first occured 
* Throwable will be thrown as Error, RuntimeException or (masked) IOException. 
* 
* The method is null-safe. 
*/ 
public static void close(@Nullable Process process) throws IOException { 
    if(process == null) { 
     return; 
    } 

    Throwable t = null; 

    try { 
     close(process.getOutputStream()); 
    } 
    catch(Throwable e) { 
     t = e; 
    } 

    try{ 
     close(process.getInputStream()); 
    } 
    catch(Throwable e) { 
     t = (t == null) ? e : t; 
    } 

    try{ 
     close(process.getErrorStream()); 
    } 
    catch (Throwable e) { 
     t = (t == null) ? e : t; 
    } 

    try{ 
     try { 
     if(process.waitFor() != 0){ 
      process.destroy(); 
     } 
     } 
     catch(InterruptedException e) { 
     t = (t == null) ? e : t; 
     process.destroy(); 
     } 
    } 
    catch (Throwable e) { 
     t = (t == null) ? e : t; 
    } 

    if(t != null) { 
     if(t instanceof Error) { 
     throw (Error) t; 
     } 

     if(t instanceof RuntimeException) { 
     throw (RuntimeException) t; 
     } 

     throw t instanceof IOException ? (IOException) t : new IOException(t); 
    } 
} 

---

public static void closeQuietly(@Nullable Logger log, @Nullable Process process) { 
    try { 
    close(process); 
    } 
    catch (Exception e) { 
    //log if Logger provided, otherwise discard 
    logError(log, "Fehler beim Schließen des Process-Objekts (inkl. underlying streams)!", e); 
    } 
} 

---

public static void close(@Nullable Closeable closeable) throws IOException { 
    if(closeable != null) { 
    closeable.close(); 
    } 
} 

方法等這些在最後塊基本上使用。

我真的很想知道的是，如果我在這個實現中安全嗎？考慮如下事情：過程對象是否在其生命週期中始終返回相同的stdin，stdout和stderr流？或者我可能會錯過之前由過程'getInputStream()，getOutputStream()和getErrorStream()方法返回的流？

有上StackOverflow.com一個相關的問題：java: closing subprocess std streams?

編輯

正如指出的我和其他人在這裏：

• InputStreams必須完全消耗掉。未完成時，子進程可能無法終止，因爲其輸出流中有未完成的數據。
• 所有三個標準流都必須關閉。無論之前是否使用過。
• 當子進程正常終止時，一切都應該沒問題。當不是那麼它必須被強行終止。
• 當子程序返回退出代碼時，我們不需要destroy()它。它已經終止。 （即使不一定以正常終止代碼0終止，但終止。）
• 我們需要監視waitFor()並在超時超時時中斷，以使進程有機會正常終止但​​在掛起時將其終止。

未答覆的部分：

• 考慮優點和並聯消耗InputStreams的缺點。或者必須按特定順序消費？

Answer 1

只是爲了讓你知道我有目前在我們的代碼庫：

public static void close(@Nullable Process process) throws IOException { 
    if (process == null) { 
    return; 
    } 

    Throwable t = null; 

    try { 
    flushQuietly(process.getOutputStream()); 
    } 
    catch (Throwable e) { 
    t = mostImportantThrowable(t, e); 
    } 

    try { 
    close(process.getOutputStream()); 
    } 
    catch (Throwable e) { 
    t = mostImportantThrowable(t, e); 
    } 

    try { 
    skipAllQuietly(null, TIMEOUT, process.getInputStream()); 
    } 
    catch (Throwable e) { 
    t = mostImportantThrowable(t, e); 
    } 

    try { 
    close(process.getInputStream()); 
    } 
    catch (Throwable e) { 
    t = mostImportantThrowable(t, e); 
    } 

    try { 
    skipAllQuietly(null, TIMEOUT, process.getErrorStream()); 
    } 
    catch (Throwable e) { 
    t = mostImportantThrowable(t, e); 
    } 

    try { 
    close(process.getErrorStream()); 
    } 
    catch (Throwable e) { 
    t = mostImportantThrowable(t, e); 
    } 

    try { 
    try { 
     Thread monitor = ThreadMonitor.start(TIMEOUT); 
     process.waitFor(); 
     ThreadMonitor.stop(monitor); 
    } 
    catch (InterruptedException e) { 
     t = mostImportantThrowable(t, e); 
     process.destroy(); 
    } 
    } 
    catch (Throwable e) { 
    t = mostImportantThrowable(t, e); 
    } 

    if (t != null) { 
    if (t instanceof Error) { 
     throw (Error) t; 
    } 

    if (t instanceof RuntimeException) { 
     throw (RuntimeException) t; 
    } 

    throw t instanceof IOException ? (IOException) t : new IOException(t); 
    } 
} 

---

skipAllQuietly(...)消耗完全InputStreams。它在內部使用類似於org.apache.commons.io.ThreadMonitor的實現來在給定的超時超過時中斷消耗。

mostImportantThrowable(...)決定應該返回什麼Throwable。一切都錯了。首先發生的高於後來發生。這裏沒什麼特別重要的，因爲這些Throwable在後面很可能被丟棄了。我們想繼續在這裏工作，我們只能拋出一個，所以我們必須決定我們在最後拋出什麼，如果有的話。

close(...)是無效的實現來關閉的東西，但拋出異常時，出現了問題。

Answer 2

在簡化你的代碼的嘗試：

public static void close(@Nullable Process process) throws IOException 
{ 
    if(process == null) { return; } 

    try 
    { 
     close(process.getOutputStream()); 
     close(process.getInputStream()); 
     close(process.getErrorStream()); 

     if(process.waitFor() != 0) 
     { 
      process.destroy(); 
     } 
    } 
    catch(InterruptedException e) 
    { 
     process.destroy(); 
    } 
    catch (RuntimeException e) 
    { 
     throw (e instanceof IOException) ? e : new IOException(e); 
    } 
} 

通過捕獲Throwable我假設你想捕捉所有未檢查異常。這是RuntimeException或Error的派生物。但是Error不應該被捕獲，所以我用RuntimeException代替Throwable。

（抓住所有RuntimeException s仍然不是一個好主意。）

Answer 3

由於您鏈接到狀態的問題，最好是讀取並放棄輸出和錯誤流。如果您使用的是Apache公地IO，像，

new Thread(new Runnable() {public void run() {IOUtils.copy(process.getInputStream(), new NullOutputStream());}}).start(); 
new Thread(new Runnable() {public void run() {IOUtils.copy(process.getErrorStream(), new NullOutputStream());}}).start(); 

你想閱讀並丟棄輸出和錯誤在一個單獨的線程，以避免出現問題，如處理阻塞時將其寫入足夠的信息到stderr或標準輸出填寫緩衝區。

如果你擔心有兩個多個線程，請參見本question

我不認爲你需要擔心複製標準輸出的時候趕上的IOExceptions，標準輸入到NullOutputStream，因爲如果有一個IOException從讀處理標準輸出/標準輸入，這可能是由於進程本身死了，寫入NullOutputStream將永遠不會拋出異常。

您不需要檢查waitFor（）的返回狀態。

是否要等待此過程完成？如果是這樣，你可以做，

while(true) { 
    try 
    { 
     process.waitFor(); 
     break; 
    } catch(InterruptedException e) { 
     //ignore, spurious interrupted exceptions can occur 
    } 

} 

你提供你需要關閉流時的過程完成的環節看，但破壞會做你。

所以最終，該方法成爲，

public void close(Process process) { 

    if(process == null) return; 

    new Thread(new Runnable() {public void run() {IOUtils.copy(process.getInputStream(), new NullOutputStream());}}).start(); 
    new Thread(new Runnable() {public void run() {IOUtils.copy(process.getErrorStream(), new NullOutputStream());}}).start(); 
    while(true) { 
     try 
     { 
      process.waitFor(); 
      //this will close stdin, stdout and stderr for the process 
      process.destroy(); 
      break; 
     } catch(InterruptedException e) { 
      //ignore, spurious interrupted exceptions can occur 
     } 

    } 
}