Android执行程序或脚本的方法

Java中提供了两种方法来执行程序或脚本：
(1) 使用Runtime的exec()方法
(2) 使用ProcessBuilder的start()方法

ProcessBuilder.start() 和 Runtime.exec() 方法都被用来创建一个操作系统进程（执行命令行操作），并返回 Process 子类的一个实例，该实例可用来控制进程状态并获得相关信息。

1.调用ProcessBuilder的构造函数后执行start():

 Process process = new ProcessBuilder("/system/bin/ping").redirectErrorStream(true).start();
 OutputStream stdout = process.getOutputStream();
 InputStream stdin = process.getInputStream();
 BufferedReader reader = new BufferedReader(new InputStreamReader(stdin));
 BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(stdout));  

2.用Runtime.getRuntime().exec()方法执行:

 Process process = Runtime.getRuntime().exec("/system/bin/ping");
 OutputStream stdout = process.getOutputStream();
 InputStream stderr = process.getErrorStream();
 InputStream stdin = process.getInputStream();
 BufferedReader reader = new BufferedReader(new InputStreamReader(stdin));
 BufferedReader err= new BufferedReader(new InputStreamReader(stderr));
 BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(stdout));  

使用ProcessBuilder，可以通过redirectErrorStream(true)将错误输出流转移到标准输出流中，这样使用一次process.getInputStreamReader()就能读出该进程的所有输出。

而使用Runtime.getRuntime().exec()方法时，错误的输出流还需通过process.getErrorStream()来获得。

waitFor方法

ProcessBuilder.start() 和 Runtime.exec() 方法创建Process 子类的一个实例。 程序主进程会等待process一定的时间，但是时间很少，可能process根本无法完成工作就结束了。 因此，针对使用较长时间做工作的process，就需要调用waitFor方法。 该方法会引起当前Thread等待，直到process中断。

此方法返回的退出值的过程。按照惯例，0表示正常终止。

下面是一个进程执行后销毁的类：

 import java.io.InputStream;
 import java.io.OutputStream;  

 public class ProcessModel {  

     /**
      * 通过Android底层实现进程关闭
      *
      * @param process
      */
     public static void killProcess(Process process) {
         int pid = getProcessId(process.toString());
         if (pid != 0) {
             try {
                 android.os.Process.killProcess(pid);
             } catch (Exception e) {
                 try {
                     process.destroy();
                 } catch (Exception ex) {
                 }
             }
         }
     }  

     /**
      * 获取当前进程的ID
      *
      * @param str
      * @return
      */
     public static int getProcessId(String str) {
         try {
             int i = str.indexOf("=") + 1;
             int j = str.indexOf("]");
             String cStr = str.substring(i, j).trim();
             return Integer.parseInt(cStr);
         } catch (Exception e) {
             return 0;
         }
     }  

     /**
      * 关闭进程的所有流
      *
      * @param process
      */
     public static void closeAllStream(Process process) {
         try {
             InputStream in = process.getInputStream();
             if (in != null)
                 in.close();
         } catch (Exception e) {
             e.printStackTrace();
         }
         try {
             InputStream in = process.getErrorStream();
             if (in != null)
                 in.close();
         } catch (Exception e) {
             e.printStackTrace();
         }
         try {
             OutputStream out = process.getOutputStream();
             if (out != null)
                 out.close();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }  

     /**
      * 销毁一个进程
      *
      * @param process
      */
     public static void processDestroy(Process process) {
         if (process != null) {
             try {
                 if (process.exitValue() != 0) {
                     closeAllStream(process);
                     killProcess(process);
                 }
             } catch (IllegalThreadStateException e) {
                 closeAllStream(process);
                 killProcess(process);
             }
         }
     }  

     /**
      * 通过线程进行异步销毁
      *
      * @param process
      */
     public static void asyncProcessDestroy(final Process process) {
         Thread thread = new Thread(new Runnable() {
             @Override
             public void run() {
                 processDestroy(process);
             }
         });
         thread.setDaemon(true);
         thread.start();
     }
 }  

为了防止主控程序被waitfor方法阻塞，需要自己新建线程来处理Process流

 Process p = Runtime.getRuntime().exec(cmd);  

 StreamGobbler errorGobbler = new StreamGobbler(p.getErrorStream(), "ERROR");              

       // kick off stderr
       errorGobbler.start();  

       StreamGobbler outGobbler = new StreamGobbler(p.getInputStream(), "STDOUT");
       // kick off stdout
       outGobbler.start();   

 p.waitFor();  

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.PrintWriter;  

 import com.sdc.callmaxent.util.FileUtil;  

 /**
  * 用于处理Runtime.getRuntime().exec产生的错误流及输出流
  * @author shaojing
  *
  */
 public 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() {
         InputStreamReader isr = null;
         BufferedReader br = null;
         PrintWriter pw = null;
         try {
             if (os != null)
                 pw = new PrintWriter(os);  

             isr = new InputStreamReader(is);
             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();
         } finally{
             FileUtil.close(pw);
             FileUtil.close(br);
             FileUtil.close(isr);
         }
     }
 }   

ProcessBuilder.start() 和 Runtime.exec() 方法都被用来创建一个操作系统进程（执行命令行操作），并返回 Process 子类的一个实例，该实例可用来控制进程状态并获得相关信息。