[转载]Process工具类，提供设置timeout功能

最新推荐文章于 2022-04-22 15:09:13 发布

akqcka6420

最新推荐文章于 2022-04-22 15:09:13 发布

阅读量309

点赞数

文章标签： runtime java 操作系统

原文链接：http://www.cnblogs.com/wmx3ng/p/4138247.html

版权

FROM:http://segmentfault.com/blog/lidonghao/1190000000372535

在前一篇博文中，简单介绍了如何使用Process类来调用命令行的功能，那样使用Process会有一个很大的问题，就是可能会出现无限阻塞的情况，永远都无法返回结果。以下是Process的API说明，注意加粗的部分。

ProcessBuilder.start() 和 Runtime.exec 方法创建一个本机进程，并返回 Process 子类的一个实例，该实例可用来控制进程并获得相关信息。Process 类提供了执行从进程输入、执行输出到进程、等待进程完成、检查进程的退出状态以及销毁（杀掉）进程的方法。
创建进程的方法可能无法针对某些本机平台上的特定进程很好地工作，比如，本机窗口进程，守护进程，Microsoft Windows 上的 Win16/DOS 进程，或者 shell 脚本。创建的子进程没有自己的终端或控制台。它的所有标准 io（即 stdin、stdout 和 stderr）操作都将通过三个流 (getOutputStream()、getInputStream() 和 getErrorStream()) 重定向到父进程。父进程使用这些流来提供到子进程的输入和获得从子进程的输出。因为有些本机平台仅针对标准输入和输出流提供有限的缓冲区大小，如果读写子进程的输出流或输入流迅速出现失败，则可能导致子进程阻塞，甚至产生死锁。

解决进程无限阻塞的方法是在执行命令时，设置一个超时时间，下面提供一个工具类，对Process使用进行包装，向外提供设置超时的接口。

ExecuteResult类，对执行命令的结果进行封装，可以从中获取退出码和输出内容。

 1 public class ExecuteResult {
 2     @Override
 3     public String toString() {
 4         return "ExecuteResult [exitCode=" + exitCode + ", executeOut="
 5                 + executeOut + "]";
 6     }
 7 
 8     private int exitCode;
 9     private String executeOut;
10 
11     public ExecuteResult(int exitCode, String executeOut) {
12         super();
13         this.exitCode = exitCode;
14         this.executeOut = executeOut;
15     }
16 
17     public int getExitCode() {
18         return exitCode;
19     }
20 
21     public void setExitCode(int exitCode) {
22         this.exitCode = exitCode;
23     }
24 
25     public String getExecuteOut() {
26         return executeOut;
27     }
28 
29     public void setExecuteOut(String executeOut) {
30         this.executeOut = executeOut;
31     }
32 
33 }

View Code

LocalCommandExecutorService 接口，向外暴露executeCommand（）方法

1 public interface LocalCommandExecutorService {
2     ExecuteResult executeCommand(String[] command, long timeout);
3 }

View Code

LocalCommandExecutorServiceImpl 实现类，实现LocalCommandExecutorService 接口的方法

 1 public class LocalCommandExecutorServiceImpl implements
 2         LocalCommandExecutorService {
 3     static final Logger logger = LoggerFactory
 4             .getLogger(LocalCommandExecutorServiceImpl.class);
 5 
 6     static ExecutorService pool = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
 7             3L, TimeUnit.SECONDS,
 8             new SynchronousQueue<Runnable>());
 9 
10     @Override
11     public ExecuteResult executeCommand(String[] command, long timeout) {
12         Process process = null;
13         InputStream pIn = null;
14         InputStream pErr = null;
15         StreamGobbler outputGobbler = null;
16         StreamGobbler errorGobbler = null;
17         Future<Integer> executeFuture = null;
18         try {
19             process = Runtime.getRuntime().exec(command);
20             final Process p = process;
21 
22             //close process's output stream.
23             p.getOutputStream().close();
24 
25             pIn = process.getInputStream();
26             outputGobbler = new StreamGobbler(
27                     pIn, "OUTPUT");
28             outputGobbler.start();
29 
30             pErr = process.getErrorStream();
31             errorGobbler = new StreamGobbler(pErr, "ERROR");
32             errorGobbler.start();
33 
34             // create a Callable for the command's Process which can be called
35             // by an Executor
36             Callable<Integer> call = new Callable<Integer>() {
37                 public Integer call() throws Exception {
38                     p.waitFor();
39                     return p.exitValue();
40                 }
41             };
42 
43             // submit the command's call and get the result from a
44             executeFuture = pool.submit(call);
45             int exitCode = executeFuture.get(timeout,
46                     TimeUnit.MILLISECONDS);
47             return new ExecuteResult(exitCode, outputGobbler.getContent());
48         } catch (IOException ex) {
49             String errorMessage = "The command [" + command
50                     + "] execute failed.";
51             logger.error(errorMessage, ex);
52             return new ExecuteResult(-1, null);
53         } catch (TimeoutException ex) {
54             String errorMessage = "The command [" + command + "] timed out.";
55             logger.error(errorMessage, ex);
56             return new ExecuteResult(-1, null);
57         } catch (ExecutionException ex) {
58             String errorMessage = "The command [" + command
59                     + "] did not complete due to an execution error.";
60             logger.error(errorMessage, ex);
61             return new ExecuteResult(-1, null);
62         } catch (InterruptedException ex) {
63             String errorMessage = "The command [" + command
64                     + "] did not complete due to an interrupted error.";
65             logger.error(errorMessage, ex);
66             return new ExecuteResult(-1, null);
67         } finally {
68             if(executeFuture != null){
69                 try{
70                 executeFuture.cancel(true);
71                 } catch(Exception ignore){}
72             }
73             if(pIn != null) {
74                 this.closeQuietly(pIn);
75                 if(outputGobbler != null && !outputGobbler.isInterrupted()){
76                     outputGobbler.interrupt();
77                 }
78             }
79             if(pErr != null) {
80                 this.closeQuietly(pErr);
81                 if(errorGobbler != null && !errorGobbler.isInterrupted()){
82                     errorGobbler.interrupt();
83                 }
84             }
85             if (process != null) {
86                 process.destroy();
87             }
88         }
89     }
90 
91       private void closeQuietly(Closeable c) {
92         try {
93             if (c != null)
94                 c.close();
95         } catch (IOException e) {
96         }
97     }
98 }

View Code

StreamGobbler类，用来包装输入输出流

 1 import java.io.BufferedReader;
 2 import java.io.IOException;
 3 import java.io.InputStream;
 4 import java.io.InputStreamReader;
 5 
 6 import org.slf4j.Logger;
 7 import org.slf4j.LoggerFactory;
 8 
 9 public class StreamGobbler extends Thread {
10     private static Logger logger = LoggerFactory.getLogger(StreamGobbler.class);
11     private InputStream inputStream;
12     private String streamType;
13     private StringBuilder buf;
14     private volatile boolean isStopped = false;
15 
16     /**
17      * Constructor.
18      * 
19      * @param inputStream
20      *            the InputStream to be consumed
21      * @param streamType
22      *            the stream type (should be OUTPUT or ERROR)
23      * @param displayStreamOutput
24      *            whether or not to display the output of the stream being
25      *            consumed
26      */
27     public StreamGobbler(final InputStream inputStream, final String streamType) {
28         this.inputStream = inputStream;
29         this.streamType = streamType;
30         this.buf = new StringBuilder();
31         this.isStopped = false;
32     }
33 
34     /**
35      * Consumes the output from the input stream and displays the lines
36      * consumed if configured to do so.
37      */
38     @Override
39     public void run() {
40         try {
41             //默认编码为UTF-8，这里设置编码为GBK，因为WIN7的编码为GBK
42             InputStreamReader inputStreamReader = new InputStreamReader(
43                     inputStream,"GBK");
44             BufferedReader bufferedReader = new BufferedReader(
45                     inputStreamReader);
46             String line = null;
47             while ((line = bufferedReader.readLine()) != null) {
48                 this.buf.append(line + "\n");
49             }
50         } catch (IOException ex) {
51             logger.trace("Failed to successfully consume and display the input stream of type "
52                             + streamType + ".", ex);
53         } finally {
54             this.isStopped = true;
55             synchronized (this) {
56                 notify();
57             }
58         }
59     }
60 
61     public String getContent() {
62         if(!this.isStopped){
63             synchronized (this) {
64                 try {
65                     wait();
66                 } catch (InterruptedException ignore) {
67                 }
68             }
69         }
70         return this.buf.toString();
71     }
72 }

View Code

测试用例

1 public class LocalCommandExecutorTest {
2     public static void main(String[] args) {
3         LocalCommandExecutorService service = new LocalCommandExecutorServiceImpl();
4         String[] command = new String[]{"ping","127.0.0.1"};
5         ExecuteResult result = service.executeCommand(command, 5000);
6         System.out.println("退出码："+result.getExitCode());
7         System.out.println("输出内容："+result.getExecuteOut());     
8     }
9 }