Java执行外部命令需要注意的地方

野性酷女 2024-04-18 22:21 62阅读 0赞

# **Runtime.getRuntime().exec()需要注意的地方** #

## 1. Process的工作原理  ##

ProcessBuilder.start() 和 Runtime.exec 方法创建一个本机进程，并返回 Process 子类的一个实例，该实例可用来控制进程并获得相关信息。  
Process 类提供了执行从进程输入、执行输出到进程、等待进程完成、检查进程的退出状态以及销毁（杀掉）进程的方法。

创建进程的方法可能无法针对某些本机平台上的特定进程很好地工作，比如，本机窗口进程，守护进程，Microsoft Windows 上的 Win16/DOS 进程，或者 shell 脚本。创建的子进程没有自己的终端或控制台。它的所有标准 io（即 stdin、stdout 和 stderr）操作都将通过三个流 (getOutputStream()、getInputStream() 和 getErrorStream()) 重定向到父进程。父进程使用这些流来提供到子进程的输入和获得从子进程的输出。

## 2. Process对象有以下几个方法： ##

1、destroy()　　　　杀死这个子进程  
2、exitValue()　　　得到进程运行结束后的返回状态  
3、waitFor()　　　　得到进程运行结束后的返回状态，如果进程未运行完毕则等待知道执行完毕  
4、getInputStream()    得到进程的标准输出信息流  
5、getErrorStream()    得到进程的错误输出信息流  
6、getOutputStream()得到进程的输入流

## 3. 风险点： ##

a) exitValue()，当线程没有执行完毕时调用此方法会跑出IllegalThreadStateException异常，最直接的解决方法就是用waitFor()方法代替。  
b) waitFor()方法也有很明显的弊端，因为java程序给进程的输出流分配的缓冲区是很小的，有时候当进程输出信息很大的时候回导致缓冲区被填满，如果不及时处理程序会阻塞。如果程序没有对进程的输出流处理的会就会导致执行exec()的线程永远阻塞，进程也不会执行下去直到输出流被处理或者java程序结束。

## 4. 解决思路： ##

解决进程无限阻塞的方法是在执行命令时，设置一个超时时间。

## 5. 案例： ##

不说废话，直接贴代码：

package com.brucexx.custom.util;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.*;
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Future;
    import java.util.concurrent.SynchronousQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    public class CmdUtil {
        
        protected static final Logger logger = LoggerFactory.getLogger(CmdUtil.class);
        static ExecutorService pool = new ThreadPoolExecutor(0, 100, 3L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        private static CmdUtil instance;
        private CmdUtil() {
        }
        public static CmdUtil getInstance() {
            if (instance == null) {
                instance = new CmdUtil();
            }
            return instance;
        }
    
        /**
         * 	执行命令CMD命令，带超时时间
         * @param command
         * @param timeOut
         * @return
         * @throws IOException
         */
        public boolean execCmd(String command ,int timeOut){
            Process process = null;
            InputStream pIn = null;
            InputStream pErr = null;
            StreamHandler outputHandler = null;
            StreamHandler errorHandler = null;
            Future<Integer> executeFuture = null;
            try {
                logger.info("开始执行命令："+command);
                process = Runtime.getRuntime().exec(command);
                final Process pf = process;
                process.getOutputStream().close();
                outputHandler = new StreamHandler(pIn = process.getInputStream(), "OUTPUT");
                outputHandler.start();
                errorHandler = new StreamHandler(pErr = process.getErrorStream(), "ERROR");
                errorHandler.start();
    
                Callable<Integer> call = new Callable<Integer>() {
                    public Integer call() throws Exception {
                        pf.waitFor();
                        return pf.exitValue();
                    }
                };
    
                executeFuture = pool.submit(call);
                int exitCode = executeFuture.get(timeOut, TimeUnit.SECONDS);
                logger.info("exitCode::" + exitCode);
                logger.info("output::" + outputHandler.getContent());
                logger.info("error::" + errorHandler.getContent());
    
                if (errorHandler.getContent().indexOf("error") == -1){
                    logger.info(command+"执行有效！");
                    return true;
                }
    
            } catch (Exception e) {
                logger.error(command+" 执行异常",e);
            } finally {
                if(executeFuture != null){
                    try{
                        executeFuture.cancel(true);
                    } catch(Exception ex){ }
                }
                if(pIn != null) {
                    //this.closeStream(pIn);
                    if(outputHandler != null && !outputHandler.isInterrupted()){
                        outputHandler.interrupt();
                    }
                }
                if(pErr != null) {
                    //this.closeStream(pErr);
                    if(errorHandler != null && !errorHandler.isInterrupted()){
                        errorHandler.interrupt();
                    }
                }
                if (process != null) {
                    System.out.println(" process.destroy()");
                    process.destroy();
                }
            }
            logger.error(command+"执行无效！");
            return false;
        }
    
        private void closeStream(Closeable c) {
            try {
                if (c != null)
                    c.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        class StreamHandler extends Thread {
            private Logger logger = LoggerFactory.getLogger(StreamHandler.class);
            private InputStream inputStream;
            private String streamType;
            private StringBuilder buf;
            private volatile boolean isStopped = false;
    
            public StreamHandler(final InputStream inputStream, final String streamType) {
                this.inputStream = inputStream;
                this.streamType = streamType;
                this.buf = new StringBuilder();
                this.isStopped = false;
            }
    
            @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 static void main(String[] args) throws IOException {
            CmdUtil.getInstance().execCmd("ping 127.0.0.1 ",60);
        }
    }

这里需要注意的一点。 这里是使用两个独立的线程来读 input和error的输出。 所以在外部程序执行完之前，无法关闭流， 所以你看代码中close stream 被注释掉了。 否则程序会一直等待外部进程的执行完成才能退出，这样定时的任务也就看不出效果。 当然我这里应用场景的特殊性，就是我只需要知道进程的执行结果如何，并不需要拿到内容。