ProcessBuilder类是J2SE 1.5在java.lang中新添加的一个新类，此类用于创建操作系统进程，它提供一种启动和管理进程（也就是应用程序）的方法。在J2SE 1.5之前，都是由Process类处来实现进程的控制管理。本文简单介绍一下Process类的用法以及一些需要注意的问题。
API方法说明如下：
- destroy() 杀掉子进程。
- exitValue() 返回子进程的出口值。该方法不阻塞，如果此 Process 对象表示的子进程尚未终止，就会抛出IllegalThreadStateException异常，中止进程
- getErrorStream() 获取子进程的错误流
- getInputStream() 获取子进程的输入流
- getOutputStream() 获取子进程的输出流，基本上不会用到输出流
- waitFor() 导致当前线程等待，如有必要，一直要等到由该 Process 对象表示的进程已经终止。导致当前线程等待，如有必要，一直要等到由该 Process对象表示的进程已经终止。如果已终止该子进程，此方法立即返回。如果没有终止该子进程，调用的线程将被阻塞，直到退出子进程
一个简单的例子：
**
* 列出所有的进程信息
*/
public class ListAllProcessTest {
public static void main(String[] args) {
BufferedReader br = null;
Process process = null;
try {
process = Runtime.getRuntime().exec("tasklist");
br = new BufferedReader(new InputStreamReader(process.getInputStream(), "GBK"));
String line = null;
System.out.println("列出所有正在运行的进程信息：");
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (Exception e) {
e.printStackTrace();
}
}
if(process!=null){
process.destroy();
}
}
}
}
程序输出如下：
直接在WIN7的命令行执行命令：tasklist，输出结果如下：
这样使用Process会有一个很大的问题，就是可能会出现无限阻塞的情况，永远都无法返回结果。以下是Process的API说明，注意加粗的部分。
ProcessBuilder.start() 和 Runtime.exec 方法创建一个本机进程，并返回 Process 子类的一个实例，该实例可用来控制进程并获得相关信息。Process 类提供了执行从进程输入、执行输出到进程、等待进程完成、检查进程的退出状态以及销毁（杀掉）进程的方法。
创建进程的方法可能无法针对某些本机平台上的特定进程很好地工作，比如，本机窗口进程，守护进程，Microsoft Windows 上的 Win16/DOS 进程，或者 shell 脚本。创建的子进程没有自己的终端或控制台。它的所有标准 io（即 stdin、stdout 和 stderr）操作都将通过三个流 (getOutputStream()、getInputStream() 和 getErrorStream()) 重定向到父进程。父进程使用这些流来提供到子进程的输入和获得从子进程的输出。因为有些本机平台仅针对标准输入和输出流提供有限的缓冲区大小，如果读写子进程的输出流或输入流迅速出现失败，则可能导致子进程阻塞，甚至产生死锁。
解决进程无限阻塞的方法是在执行命令时，设置一个超时时间，下面提供一个工具类，对Process使用进行包装，向外提供设置超时的接口。
ExecuteResult类，对执行命令的结果进行封装，可以从中获取退出码和输出内容。
public class ExecuteResult {
@Override
public String toString() {
return "ExecuteResult [exitCode=" + exitCode + ", executeOut="
+ executeOut + "]";
}
private int exitCode;
private String executeOut;
public ExecuteResult(int exitCode, String executeOut) {
super();
this.exitCode = exitCode;
this.executeOut = executeOut;
}
public int getExitCode() {
return exitCode;
}
public void setExitCode(int exitCode) {
this.exitCode = exitCode;
}
public String getExecuteOut() {
return executeOut;
}
public void setExecuteOut(String executeOut) {
this.executeOut = executeOut;
}
}
LocalCommandExecutorService 接口，向外暴露executeCommand（）方法
public interface LocalCommandExecutorService {
ExecuteResult executeCommand(String[] command, long timeout);
}
LocalCommandExecutorServiceImpl 实现类，实现LocalCommandExecutorService 接口的方法
public class LocalCommandExecutorServiceImpl implements
LocalCommandExecutorService {
static final Logger logger = LoggerFactory
.getLogger(LocalCommandExecutorServiceImpl.class);
static ExecutorService pool = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
3L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
@Override
public ExecuteResult executeCommand(String[] command, long timeout) {
Process process = null;
InputStream pIn = null;
InputStream pErr = null;
StreamGobbler outputGobbler = null;
StreamGobbler errorGobbler = null;
Future<Integer> executeFuture = null;
try {
process = Runtime.getRuntime().exec(command);
final Process p = process;
//close process's output stream.
p.getOutputStream().close();
pIn = process.getInputStream();
outputGobbler = new StreamGobbler(
pIn, "OUTPUT");
outputGobbler.start();
pErr = process.getErrorStream();
errorGobbler = new StreamGobbler(pErr, "ERROR");
errorGobbler.start();
// create a Callable for the command's Process which can be called
// by an Executor
Callable<Integer> call = new Callable<Integer>() {
public Integer call() throws Exception {
p.waitFor();
return p.exitValue();
}
};
// submit the command's call and get the result from a
executeFuture = pool.submit(call);
int exitCode = executeFuture.get(timeout,
TimeUnit.MILLISECONDS);
return new ExecuteResult(exitCode, outputGobbler.getContent());
} catch (IOException ex) {
String errorMessage = "The command [" + command
+ "] execute failed.";
logger.error(errorMessage, ex);
return new ExecuteResult(-1, null);
} catch (TimeoutException ex) {
String errorMessage = "The command [" + command + "] timed out.";
logger.error(errorMessage, ex);
return new ExecuteResult(-1, null);
} catch (ExecutionException ex) {
String errorMessage = "The command [" + command
+ "] did not complete due to an execution error.";
logger.error(errorMessage, ex);
return new ExecuteResult(-1, null);
} catch (InterruptedException ex) {
String errorMessage = "The command [" + command
+ "] did not complete due to an interrupted error.";
logger.error(errorMessage, ex);
return new ExecuteResult(-1, null);
} finally {
if(executeFuture != null){
try{
executeFuture.cancel(true);
} catch(Exception ignore){}
}
if(pIn != null) {
this.closeQuietly(pIn);
if(outputGobbler != null && !outputGobbler.isInterrupted()){
outputGobbler.interrupt();
}
}
if(pErr != null) {
this.closeQuietly(pErr);
if(errorGobbler != null && !errorGobbler.isInterrupted()){
errorGobbler.interrupt();
}
}
if (process != null) {
process.destroy();
}
}
}
private void closeQuietly(Closeable c) {
try {
if (c != null)
c.close();
} catch (IOException e) {
}
}
}
StreamGobbler类，用来包装输入输出流
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class StreamGobbler extends Thread {
private static Logger logger = LoggerFactory.getLogger(StreamGobbler.class);
private InputStream inputStream;
private String streamType;
private StringBuilder buf;
private volatile boolean isStopped = false;
/**
* Constructor.
*
* @param inputStream
* the InputStream to be consumed
* @param streamType
* the stream type (should be OUTPUT or ERROR)
* @param displayStreamOutput
* whether or not to display the output of the stream being
* consumed
*/
public StreamGobbler(final InputStream inputStream, final String streamType) {
this.inputStream = inputStream;
this.streamType = streamType;
this.buf = new StringBuilder();
this.isStopped = false;
}
/**
* Consumes the output from the input stream and displays the lines
* consumed if configured to do so.
*/
@Override
public void run() {
try {
//默认编码为UTF-8，这里设置编码为GBK，因为WIN7的编码为GBK
InputStreamReader inputStreamReader = new InputStreamReader(
inputStream,"GBK");
BufferedReader bufferedReader = new BufferedReader(
inputStreamReader);
String line = null;
while ((line = bufferedReader.readLine()) != null) {
this.buf.append(line + "\n");
}
} catch (IOException ex) {
logger.trace("Failed to successfully consume and display the input stream of type "
+ streamType + ".", ex);
} finally {
this.isStopped = true;
synchronized (this) {
notify();
}
}
}
public String getContent() {
if(!this.isStopped){
synchronized (this) {
try {
wait();
} catch (InterruptedException ignore) {
}
}
}
return this.buf.toString();
}
}
测试用例
public class LocalCommandExecutorTest {
public static void main(String[] args) {
LocalCommandExecutorService service = new LocalCommandExecutorServiceImpl();
String[] command = new String[]{"ping","127.0.0.1"};
ExecuteResult result = service.executeCommand(command, 5000);
System.out.println("退出码："+result.getExitCode());
System.out.println("输出内容："+result.getExecuteOut());
}
}
}输出结果如下：
直接在命令行执行“ping 127.0.0.1”，结果如下：
Apache提供了一个开源库，对Process类进行了封装，也提供了设置超时的功能，建议在项目中使用
Apache Commons Exec这个开源库来实现超时功能，除了功能更强大外，稳定性也有保障。（待查询）
