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 子类的一个实例，该实例可用来控制进程状态并获得相关信息。