Runtime.exec() 的陷阱
原文地址：http://www.javaworld.com/javaworld/jw-12-2000/jw-1229-traps.html?page=4
作为Java语言的一部分。java.lang包被隐藏的导入到每一个Java程序。这个包的表面陷阱，经常影响到大多数程序员。这个月，我将讨论运行时exec()方法时的潜伏陷阱。
陷阱4:当运行exec()不会
exec()有四个重载:
public Process exec(String command);
public Process exec(String [] cmdArray);
public Process exec(String command, String [] envp);
public Process exec(String [] cmdArray, String [] envp);
对于每个这样的方法，都会产生一个命令，并可能携带一组参数——被传递给一个特定操作系统的函数调用。这随后创建一个特定操作系统的进程(一个运行着的程序)，procss类将持有该程序返回Java VM的引用。这个procss类是一个抽象类，具体子类的实现依赖于不同的底层操作系统。
你可以通过三种可能的输入参数到这些方法：
1、一个字符串,表示程序执行和程序的任何参数。
2、一个字符串数组，通过参数来区分出程序的实现功能。
3、一个环境变量的数组
传递环境变量是，使用格式化的方式：名称=值。如果你使用单个字符串和它的参数的方式调用exec()的重载，,注意字符串是通过StringTokenizer类被解析，使用空格作为分隔符。
陷入 IllegalThreadStateException
运行exec()的第一个陷阱，是theIllegalThreadStateException。 普遍上，第一次对api的尝试，都是基于一些最常用的方法。例如，执行一个java vm的外部过程，我们使用exec()方法。查看外部过程的返回值，我们使用process类的exitValue()方法。看到的值外部过程的回报,我们使用exitValue()方法在过程类。在我们的第一个示例中,我们将尝试执行Java编译器(javac exe)。
清单 4.1 BadExecJavac.java
import java.util.*;
import java.io.*;
public class BadExecJavac
{
public static void main(String args[])
{
try
{
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("javac");
int exitVal = proc.exitValue();
System.out.println("Process exitValue: " + exitVal);
} catch (Throwable t)
{
t.printStackTrace();
}
}
}
运行的BadExecJavac产生：
E:\classes\com\javaworld\jpitfalls\article2>java BadExecJavac
java.lang.IllegalThreadStateException: process has not exited
at java.lang.Win32Process.exitValue(Native Method)
at BadExecJavac.main(BadExecJavac.java:13)
如果一个外部进程尚未完成，exitValue()方法将抛出IllegalThreadStateException。这就是程序失败的原因。尽管文档声明了这个事实，为什么这个方法不能等待一个有效性的结果返回？
更彻底的看看process的可用方法，我们发现waitFor()方法,能准确地完成这一工作。事实上,waitFor()也返回退出值,这意味着你不用同时使用exitValue()和waitFor(),而是选择其中之一。唯一可能的情况，你会使用exitValue()而不是waitFor()，是当你不希望你的程序块等待一个外部的过程，而这个外部过程可能永远不会完成。取代waitFor()方法,我宁愿在exitValue()方法内部，传递一个布尔参数称为waitFor，来确定是否当前线程应该等待。一个布尔变量会更好,因为exitValue()是一个更合适的名称,,也没有必要让两个方法在在不同条件下来执行相同的功能。这种简单的通过输入参数传递，来区分条件，执行不同的功能。
因此,为了避免这个陷阱,要么抓住theIllegalThreadStateException或等待进程完成。
现在,让我们在清单4.1的基础，通过等待进程完成来解决这个问题。清单4.2,程序会再次execute javac.exx，然后等待外部过程来完成。
清单4.2 BadExecJavac2.java
import java.util.*;
import java.io.*;
public class BadExecJavac2
{
public static void main(String args[])
{
try
{
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("javac");
int exitVal = proc.waitFor();
System.out.println("Process exitValue: " + exitVal);
} catch (Throwable t)
{
t.printStackTrace();
}
}
}
不幸的是,一个运行的BadExecJavac2不产生任何输出。程序挂起、一直未完成。为什么javac进程一直没有完成?
为什么 Runtime.exec() 挂起
JDK的Javadoc文档提供了这个问题的答案:
因为一些本机平台只提供有限的缓冲区大小为标准输入和输出流,未能及时写输入流或读取输出流的子流程可能会导致子流程阻止,甚至死锁。
这只是程序员不阅读文档的一个案例。隐含常听到的建议:读好手册(RTFM)?答案是部分是的。在这种情况下,阅读Javadoc将让你停在半途;它解释说,你需要处理流到你的外部过程,但是它没有告诉你怎样做。
这个问题,原因明显是大量程序员的问题和误解这个API有关信息:尽管运行exec()和流程API看起来非常简单,那简单是欺骗,因为简单,或者说是明显,使用的API是容易出错。这里给API设计师的建议是，为简单的操作保留简单的API。容易产生复杂性操作和具有特定平台依赖性应该准确反映问题域。有可能某个抽象进行的太深。这个JConfig库提供了一个示例的一个更完整的API来处理文件和流程操作(请参阅下面的Resources参考资料以获得更多信息)。
现在,让我们遵循JDK文档和处理输出的javac过程。当您运行javac不带任何参数,它产生一组使用语句,描述了如何运行这个程序及其意义的所有可用的程序的选项。了解这些信息会到stderr（标准错误）流,您可以很容易地编写一个程序,在等待进程退出前检测这个输出流。
清单4.3完成这个任务。虽然这种方法可以运行,但这不是一个好的通用解决方案。因此,清单4.3的程序被命名为MediocreExecJavac;它只提供了一个平庸的解决方案。一个更好的解决方案将不输出或者清空标准错误流和标准输出流。最好的解决方案将清空这些流(我之后将证明)。
清单 4.3 MediocreExecJavac.java
import java.util.*;
import java.io.*;
public class MediocreExecJavac
{
public static void main(String args[])
{
try
{
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("javac");
InputStream stderr = proc.getErrorStream();
InputStreamReader isr = new InputStreamReader(stderr);
BufferedReader br = new BufferedReader(isr);
String line = null;
System.out.println("<ERROR>");
while ( (line = br.readLine()) != null)
System.out.println(line);
System.out.println("</ERROR>");
int exitVal = proc.waitFor();
System.out.println("Process exitValue: " + exitVal);
} catch (Throwable t)
{
t.printStackTrace();
}
}
}
运行
MediocreExecJava产生：
E:\classes\com\javaworld\jpitfalls\article2>java MediocreExecJavac
<ERROR>
Usage: javac <options> <source files>
where <options> includes:
-g Generate all debugging info
-g:none Generate no debugging info
-g:{lines,vars,source} Generate only some debugging info
-O Optimize; may hinder debugging or enlarge class files
-nowarn Generate no warnings
-verbose Output messages about what the compiler is doing
-deprecation Output source locations where deprecated APIs are used
-classpath <path> Specify where to find user class files
-sourcepath <path> Specify where to find input source files
-bootclasspath <path> Override location of bootstrap class files
-extdirs <dirs> Override location of installed extensions
-d <directory> Specify where to place generated class files
-encoding <encoding> Specify character encoding used by source files
-target <release> Generate class files for specific VM version
</ERROR>
Process exitValue: 2
所以,MediocreExecJavac运行产生一个退出值2。通常,一个退出值0表示成功，任何非零值表示一个错误。这些退出值的含义取决于特定的操作系统。一个Win32错误值为2是一个“未找到文件”错误。这是有道理的,因为javac期望我们遵循的程序源代码文件进行编译。
因此,绕过第二个陷阱——永远挂在运行时exec()——如果你运行的程序产生输出或期望的输入,确保程序的输入和输出流。
假设一个命令是一个可执行程序
在Windows操作系统,许多新程序员运行exec()，当试图使用它来完成为非执行命令，像dir和复制，他们就掉进了运行exec()的第三陷阱。清单4.4展示的正是这种情况:
清单 4.4 BadExecWinDir.java
import java.util.*;
import java.io.*;
public class BadExecWinDir
{
public static void main(String args[])
{
try
{
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("dir");
InputStream stdin = proc.getInputStream();
InputStreamReader isr = new InputStreamReader(stdin);
BufferedReader br = new BufferedReader(isr);
String line = null;
System.out.println("<OUTPUT>");
while ( (line = br.readLine()) != null)
System.out.println(line);
System.out.println("</OUTPUT>");
int exitVal = proc.waitFor();
System.out.println("Process exitValue: " + exitVal);
} catch (Throwable t)
{
t.printStackTrace();
}
}
}
运行
BadExecWinDir输出：
E:\classes\com\javaworld\jpitfalls\article2>java BadExecWinDir
java.io.IOException: CreateProcess: dir error=2
at java.lang.Win32Process.create(Native Method)
at java.lang.Win32Process.<init>(Unknown Source)
at java.lang.Runtime.execInternal(Native Method)
at java.lang.Runtime.exec(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at BadExecWinDir.main(BadExecWinDir.java:12)
如前所述,误差值为2的意思是“未找到文件”,在这种情况下,意味着可执行文件名为dir.exe不能被发现。这是因为目录命令是Windows命令解释器的一部分,而不是一个单独的可执行文件。要运行Windows命令解释器,执行orcmd.exe或者command.com,这取决于您使用的Windows操作系统。清单4.5运行的一个Windows命令解释器，然后执行用户提供的命令(如。,dir)。
清单 4.5 GoodWindowsExec.java
import java.util.*;
import java.io.*;
class StreamGobbler extends Thread
{
InputStream is;
String type;
StreamGobbler(InputStream is, String type)
{
this.is = is;
this.type = type;
}
public void run()
{
try
{
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line=null;
while ( (line = br.readLine()) != null)
System.out.println(type + ">" + line);
} catch (IOException ioe)
{
ioe.printStackTrace();
}
}
}
public class GoodWindowsExec
{
public static void main(String args[])
{
if (args.length < 1)
{
System.out.println("USAGE: java GoodWindowsExec <cmd>");
System.exit(1);
}
try
{
String osName = System.getProperty("os.name" );
String[] cmd = new String[3];
if( osName.equals( "Windows NT" ) )
{
cmd[0] = "cmd.exe" ;
cmd[1] = "/C" ;
cmd[2] = args[0];
}
else if( osName.equals( "Windows 95" ) )
{
cmd[0] = "command.com" ;
cmd[1] = "/C" ;
cmd[2] = args[0];
}
Runtime rt = Runtime.getRuntime();
System.out.println("Execing " + cmd[0] + " " + cmd[1]
+ " " + cmd[2]);
Process proc = rt.exec(cmd);
// any error message?
StreamGobbler errorGobbler = new
StreamGobbler(proc.getErrorStream(), "ERROR");
// any output?
StreamGobbler outputGobbler = new
StreamGobbler(proc.getInputStream(), "OUTPUT");
// kick them off
errorGobbler.start();
outputGobbler.start();
// any error???
int exitVal = proc.waitFor();
System.out.println("ExitValue: " + exitVal);
} catch (Throwable t)
{
t.printStackTrace();
}
}
}
使用dir命令，运行GoodWindowsExec产生:
E:\classes\com\javaworld\jpitfalls\article2>java GoodWindowsExec "dir *.java"
Execing cmd.exe /C dir *.java
OUTPUT> Volume in drive E has no label.
OUTPUT> Volume Serial Number is 5C5F-0CC9
OUTPUT>
OUTPUT> Directory of E:\classes\com\javaworld\jpitfalls\article2
OUTPUT>
OUTPUT>10/23/00 09:01p 805 BadExecBrowser.java
OUTPUT>10/22/00 09:35a 770 BadExecBrowser1.java
OUTPUT>10/24/00 08:45p 488 BadExecJavac.java
OUTPUT>10/24/00 08:46p 519 BadExecJavac2.java
OUTPUT>10/24/00 09:13p 930 BadExecWinDir.java
OUTPUT>10/22/00 09:21a 2,282 BadURLPost.java
OUTPUT>10/22/00 09:20a 2,273 BadURLPost1.java
... (some output omitted for brevity)
OUTPUT>10/12/00 09:29p 151 SuperFrame.java
OUTPUT>10/24/00 09:23p 1,814 TestExec.java
OUTPUT>10/09/00 05:47p 23,543 TestStringReplace.java
OUTPUT>10/12/00 08:55p 228 TopLevel.java
OUTPUT> 22 File(s) 46,661 bytes
OUTPUT> 19,678,420,992 bytes free
ExitValue: 0
GoodWindowsExec运行与任何相关的文档类型将启动与之关联文档类型的应用程序。例如,启动Microsoft Word来显示一个Word文档(即一个带doc扩展名的文件)。
>java GoodWindowsExec "yourdoc.doc"
注意,GoodWindowsExec使用操作系统的系统 名字属性来确定，您运行的是哪种Windows操作系统,从而确定适当的命令解释器。
在执行命令解释器,使用StreamGobbler类来处理标准错误和标准输入流。StreamGobbler通过独立线程，来清空任何传递到它的流。这个类使用一个简单的字符串类型来表示流清空，在当它将打印行输出到控制台时起作用。
因此,为了避免运行exec()的第三个陷阱,首先不要认为一个命令是一个可执行程序;其次要了解你是否正在执行一个独立的可执行文件或一种解释命令。在结束这一节中,我将演示一个简单的命令行工具,可以帮你分析。
值得注意的是,用于获取一个进程的输出流的方法叫做getInputStream()。要记住的是,API看待对象的角度,是从Java程序内部,而不是外部的过程。因此,外部程序的输出是Java程序的输入。这种逻辑，也表明外部程序的输入流，是一个Java程序的输出流。
Runtime.exec()不是命令行
最后一个陷阱是，错误的假设命令行（shell）能接受的字符串，在Runtime.exec()内也能接受。运行exec()会受到更多的限制,而且不能跨平台。这个陷阱是由于用户试图使用exec()方法，接受一个符合命令行可执行的字符串。混乱可能是因为command是exec()方法的参数名。因此,程序员错误地将参数command与他可以输入命令行的东西联系起来,而不是将它看做单个程序及其参数。下面的清单4.6中,一个用户尝试执行命令和重定向输出在一个调用exec():
清单 4.6 BadWinRedirect.java
import java.util.*;
import java.io.*;
// StreamGobbler omitted for brevity
public class BadWinRedirect
{
public static void main(String args[])
{
try
{
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("java jecho 'Hello World' > test.txt");
// any error message?
StreamGobbler errorGobbler = new
StreamGobbler(proc.getErrorStream(), "ERROR");
// any output?
StreamGobbler outputGobbler = new
StreamGobbler(proc.getInputStream(), "OUTPUT");
// kick them off
errorGobbler.start();
outputGobbler.start();
// any error???
int exitVal = proc.waitFor();
System.out.println("ExitValue: " + exitVal);
} catch (Throwable t)
{
t.printStackTrace();
}
}
}
运行BadWinRedirect 产生:
E:\classes\com\javaworld\jpitfalls\article2>java BadWinRedirect
OUTPUT>'Hello World' > test.txt
ExitValue: 0
清单4.7 GoodWinRedirect.java
import java.util.*;
import java.io.*;
class StreamGobbler extends Thread
{
InputStream is;
String type;
OutputStream os;
StreamGobbler(InputStream is, String type)
{
this(is, type, null);
}
StreamGobbler(InputStream is, String type, OutputStream redirect)
{
this.is = is;
this.type = type;
this.os = redirect;
}
public void run()
{
try
{
PrintWriter pw = null;
if (os != null)
pw = new PrintWriter(os);
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line=null;
while ( (line = br.readLine()) != null)
{
if (pw != null)
pw.println(line);
System.out.println(type + ">" + line);
}
if (pw != null)
pw.flush();
} catch (IOException ioe)
{
ioe.printStackTrace();
}
}
}
public class GoodWinRedirect
{
public static void main(String args[])
{
if (args.length < 1)
{
System.out.println("USAGE java GoodWinRedirect <outputfile>");
System.exit(1);
}
try
{
FileOutputStream fos = new FileOutputStream(args[0]);
Runtime rt = Runtime.getRuntime();
Process proc = rt.exec("java jecho 'Hello World'");
// any error message?
StreamGobbler errorGobbler = new
StreamGobbler(proc.getErrorStream(), "ERROR");
// any output?
StreamGobbler outputGobbler = new
StreamGobbler(proc.getInputStream(), "OUTPUT", fos);
// kick them off
errorGobbler.start();
outputGobbler.start();
// any error???
int exitVal = proc.waitFor();
System.out.println("ExitValue: " + exitVal);
fos.flush();
fos.close();
} catch (Throwable t)
{
t.printStackTrace();
}
}
}
运行 GoodWinRedirect 产生:
E:\classes\com\javaworld\jpitfalls\article2>java GoodWinRedirect test.txt OUTPUT>'Hello World' ExitValue: 0
在运行GoodWinRedirect、test.txt确实存在。解决这个陷阱很简单，就是通过外部进程控制重定向的标准输出流，独立于exec()方法。我们创建一个单独的OutputStream、读取的文件名，打开文件，我们将从派生进程的标准输出 写到文件。清单4.7 通过对StreamGobbler类添加一个新的构造器来完成这个任务。新构造函数有三个参数:读入输入流,String类型标记我们是否正在使用 读入输出流,重定向输入。这个新版本的StreamGobbler并不违反任何代码之前使用的,因为我们没有改变现有的公共API——我们只扩展它。
因为参数来运行exec()是依赖于操作系统、不同系统之间的适用命令会有所变化。所以,在最终确定 Runtime.exec()参数和编写代码,快速测试。清单4.8是一个简单的命令行工具,允许你这样做。
这是一个有用的练习:尝试修改TestExec重定向标准输入和标准输出到一个文件。当在 Windows 95或Windows 98上执行javac编译器,这将解决错误消息超出命令行有限缓存的 问题。
清单4.8 TestExec.java
import java.util.*; import java.io.*; // class StreamGobbler omitted for brevity public class TestExec { public static void main(String args[]) { if (args.length < 1) { System.out.println("USAGE: java TestExec \"cmd\""); System.exit(1); } try { String cmd = args[0]; Runtime rt = Runtime.getRuntime(); Process proc = rt.exec(cmd); // any error message? StreamGobbler errorGobbler = new StreamGobbler(proc.getErrorStream(), "ERR"); // any output? StreamGobbler outputGobbler = new StreamGobbler(proc.getInputStream(), "OUT"); // kick them off errorGobbler.start(); outputGobbler.start(); // any error??? int exitVal = proc.waitFor(); System.out.println("ExitValue: " + exitVal); } catch (Throwable t) { t.printStackTrace(); } } }
运行TestExec 启动Netscape浏览器和加载Java帮助文档 产生：
E:\classes\com\javaworld\jpitfalls\article2>java TestExec "e:\java\docs\index.html"
java.io.IOException: CreateProcess: e:\java\docs\index.html error=193
at java.lang.Win32Process.create(Native Method)
at java.lang.Win32Process.<init>(Unknown Source)
at java.lang.Runtime.execInternal(Native Method)
at java.lang.Runtime.exec(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at java.lang.Runtime.exec(Unknown Source)
at TestExec.main(TestExec.java:45)
我们的第一个测试失败，错误193。Win32误差值193“不是一个有效的Win32应用程序。“这个错误告诉我们,没有找到关联的应用程序(如网景浏览器)存在,而且这一流程不能运行一个HTML文件没有关联的应用程序。
因此,我们尝试测试,这次又给它一个完整路径网景。(或者,我们可以添加到我们的PATH environment网景变量)。第二次运行的TestExec产生:
ok!网景浏览器的打开,然后装入Java帮助文档。E:\classes\com\javaworld\jpitfalls\article2>java TestExec "e:\program files\netscape\program\netscape.exe e:\java\docs\index.html" ExitValue: 0
一个额外的改进包括一个命令行开关，使TestExec接受 从标准输入的输入流。然后您将使用Process.getOutputStream()方法通过输入派生外部程序。
总之,遵循这些法则,以避免的陷阱在运行时执行():
你不能从外部过程获得一个退出状态，直到它已经退出
你必须从你外部程序立即处理输入、输出和错误流
您必须使用运行时exec()来执行程序
你不能使用运行时执行()就像一个命令行
你必须从你外部程序立即处理输入、输出和错误流
您必须使用运行时exec()来执行程序
你不能使用运行时执行()就像一个命令行