Runtime.exec() 的陷阱

原文地址：http://www.javaworld.com/javaworld/jw-12-2000/jw-1229-traps.html?page=4作为Java语言的一部分。java.lang包被隐藏的导入到每一个Java程序。这个包的表面陷阱，经常影响到大多数程序员。这个月，我将讨论运行时exec()方法时的潜伏陷阱。

陷阱4:当运行exec()不会

java.lang.Runtime类，突出了静态方法calledgetRuntime(),，它会检索当前的Java运行时环境。这是唯一的方法来获取Runtime对象的引用。获取该引用，您通过可以调用Runtime类的exec()方法运行外部程序。开发人员经常调用这个方法来启动浏览器显示一个HTML帮助页面。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编译器(javacexe)。清单 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 BadExecWinDirjava.io.IOException: CreateProcess: dir error=2at 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 = newStreamGobbler(proc.getErrorStream(), "ERROR");// any output?StreamGobbler outputGobbler = newStreamGobbler(proc.getInputStream(), "OUTPUT");// kick them offerrorGobbler.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 *.javaOUTPUT> Volume in drive E has no label.OUTPUT> Volume Serial Number is 5C5F-0CC9OUTPUT>OUTPUT> Directory of E:\classes\com\javaworld\jpitfalls\article2OUTPUT>OUTPUT>10/23/00  09:01p                   805 BadExecBrowser.javaOUTPUT>10/22/00  09:35a                   770 BadExecBrowser1.javaOUTPUT>10/24/00  08:45p                   488 BadExecJavac.javaOUTPUT>10/24/00  08:46p                   519 BadExecJavac2.javaOUTPUT>10/24/00  09:13p                   930 BadExecWinDir.javaOUTPUT>10/22/00  09:21a                 2,282 BadURLPost.javaOUTPUT>10/22/00  09:20a                 2,273 BadURLPost1.java... (some output omitted for brevity)OUTPUT>10/12/00  09:29p                   151 SuperFrame.javaOUTPUT>10/24/00  09:23p                 1,814 TestExec.javaOUTPUT>10/09/00  05:47p                23,543 TestStringReplace.javaOUTPUT>10/12/00  08:55p                   228 TopLevel.javaOUTPUT>              22 File(s)         46,661 bytesOUTPUT>                         19,678,420,992 bytes freeExitValue: 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 brevitypublic 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 = newStreamGobbler(proc.getErrorStream(), "ERROR");// any output?StreamGobbler outputGobbler = newStreamGobbler(proc.getInputStream(), "OUTPUT");// kick them offerrorGobbler.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 BadWinRedirectOUTPUT>'Hello World' > test.txtExitValue: 0

    该程序BadWinRedirect试图重定向Java版本的echo程序输出到文件test.txt。 然而,我们发现文件test.txt并不存在。jecho的程序只需要它的命令行参数,并将其写入到标准输出流。(你会发现jecho的源代码在源代码可供下载inResources.)清单4.6,用户认为你可以重定向标准输出到一个文件中，就像你可能在一个DOS命令行中执行一样。然而,你不能通过这种方法重定向输出。这里不正确的假设是，exec()方法会像一个shell解析器一样，但是它不会。相反,exec()执行一个单一可执行文件(一个程序或脚本)。如果你想处理流重定向或管道,要么用另一个程序实现,你必须通过编程,使用java。io包。清单4.7完成重定向标准输出流的jecho流程到一个文件中。清单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 = newStreamGobbler(proc.getErrorStream(), "ERROR");// any output?StreamGobbler outputGobbler = newStreamGobbler(proc.getInputStream(), "OUTPUT", fos);// kick them offerrorGobbler.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.txtOUTPUT>'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 brevitypublic 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 = newStreamGobbler(proc.getErrorStream(), "ERR");// any output?StreamGobbler outputGobbler = newStreamGobbler(proc.getInputStream(), "OUT");// kick them offerrorGobbler.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=193at 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产生:

E:\classes\com\javaworld\jpitfalls\article2>java TestExec"e:\program files\netscape\program\netscape.exe e:\java\docs\index.html"ExitValue: 0

ok!网景浏览器的打开,然后装入Java帮助文档。一个额外的改进包括一个命令行开关，使TestExec接受从标准输入的输入流。然后您将使用Process.getOutputStream()方法通过输入派生外部程序。总之,遵循这些法则,以避免的陷阱在运行时执行():你不能从外部过程获得一个退出状态，直到它已经退出你必须从你外部程序立即处理输入、输出和错误流您必须使用运行时exec()来执行程序你不能使用运行时执行()就像一个命令行