浅谈Java多进程程序的运行模式

一般我们在java中运行其它类中的方法时，无论是静态调用，还是动态调用，都是在当前的进程中执行的，也就是说，只有一个java虚拟机实例在运行。而有的时候，我们需要通过java代码启动多个java子进程。这样做虽然占用了一些系统资源，但会使程序更加稳定，因为新启动的程序是在不同的虚拟机进程中运行的，如果有一个进程发生异常，并不影响其它的子进程。

在java中我们可以使用两种方法来实现这种要求。最简单的方法就是通过runtime中的exec方法执行java classname。如果执行成功，这个方法返回一个process对象，如果执行失败，将抛出一个ioexception错误。下面让我们来看一个简单的例子。

// test1.java文件
import java.io.*;
public class test
{
public static void main(string[] args)
{
fileoutputstream fout = new fileoutputstream("c://test1.txt");
fout.close();
system.out.println("被调用成功!");
}
}

// test_exec.java
public class test_exec
{
public static void main(string[] args)
{
runtime run = runtime.getruntime();
process p = run.exec("java test1");
}
}

通过java test_exec运行程序后，发现在c盘多了个test1.txt文件，但在控制台中并未出现"被调用成功！"的输出信息。因此可以断定，test已经被执行成功，但因为某种原因，test的输出信息未在test_exec的控制台中输出。这个原因也很简单，因为使用exec建立的是test_exec 的子进程，这个子进程并没有自己的控制台，因此，它并不会输出任何信息。

如果要输出子进程的输出信息，可以通过process中的getinputstream得到子进程的输出流（在子进程中输出，在父进程中就是输入），然后将子进程中的输出流从父进程的控制台输出。具体的实现代码如下如示：

// test_exec_out.java
import java.io.*;
public class test_exec_out
{
public static void main(string[] args)
{
runtime run = runtime.getruntime();
process p = run.exec("java test1");
bufferedinputstream in = new bufferedinputstream(p.getinputstream());
bufferedreader br = new bufferedreader(new inputstreamreader(in));
string s;
while ((s = br.readline()) != null)
system.out.println(s);
}
}

从上面的代码可以看出，在test_exec_out.java中通过按行读取子进程的输出信息，然后在test_exec_out中按每行进行输出。上面讨论的是如何得到子进程的输出信息。那么，除了输出信息，还有输入信息。既然子进程没有自己的控制台，那么输入信息也得由父进程提供。我们可以通过 process的getoutputstream方法来为子进程提供输入信息（即由父进程向子进程输入信息，而不是由控制台输入信息）。我们可以看看如下的代码：

// test2.java文件
import java.io.*;
public class test
{
public static void main(string[] args)
{
bufferedreader br = new bufferedreader(new inputstreamreader(system.in));
system.out.println("由父进程输入的信息：" + br.readline());
}
}

// test_exec_in.java
import java.io.*;
public class test_exec_in
{
public static void main(string[] args)
{
runtime run = runtime.getruntime();
process p = run.exec("java test2");
bufferedwriter bw = new bufferedwriter(new outputstreamwriter(p.getoutputstream()));
bw.write("向子进程输出信息");
bw.flush();
bw.close(); // 必须得关闭流，否则无法向子进程中输入信息
// system.in.read();
　}
}

从以上代码可以看出，test1得到由test_exec_in发过来的信息，并将其输出。当你不加bw.flash()和bw.close()时，信息将无法到达子进程，也就是说子进程进入阻塞状态，但由于父进程已经退出了，因此，子进程也跟着退出了。如果要证明这一点，可以在最后加上 system.in.read()，然后通过任务管理器（在windows下）查看java进程，你会发现如果加上bw.flush()和 bw.close()，只有一个java进程存在，如果去掉它们，就有两个java进程存在。这是因为，如果将信息传给test2，在得到信息后， test2就退出了。在这里有一点需要说明一下，exec的执行是异步的，并不会因为执行的某个程序阻塞而停止执行下面的代码。因此，可以在运行 test2后，仍可以执行下面的代码。
exec方法经过了多次的重载。上面使用的只是它的一种重载。它还可以将命令和参数分开，如exec("java.test2")可以写成exec("java", "test2")。exec还可以通过指定的环境变量运行不同配置的java虚拟机。

除了使用runtime的exec方法建立子进程外，还可以通过processbuilder建立子进程。processbuilder的使用方法如下：

// test_exec_out.java
import java.io.*;
public class test_exec_out
{
public static void main(string[] args)
{
processbuilder pb = new processbuilder("java", "test1");
process p = pb.start();
… …
}
}

在建立子进程上，processbuilder和runtime类似，不同的processbuilder使用start()方法启动子进程，而runtime使用exec方法启动子进程。得到process后，它们的操作就完全一样的。

processbuilder和runtime一样，也可设置可执行文件的环境信息、工作目录等。下面的例子描述了如何使用processbuilder设置这些信息。

processbuilder pb = new processbuilder("command", "arg2", "arg2", ''');
// 设置环境变量
map<string, string> env = pb.environment();
env.put("key1", "value1");
env.remove("key2");
env.put("key2", env.get("key1") + "_test");
pb.directory("../abcd"); // 设置工作目录
process p = pb.start(); // 建立子进程

进程阻塞问题 
  由process代表的进程在某些平台上有时候并不能很好的工作，特别是在对代表进程的标准输入流、输出流和错误输出进行操作时，如果使用不慎，有可能导致进程阻塞，甚至死锁。
如果将以上事例中的从标准输出重读取信息的语句修改为从错误输出流中读取： 

  stdout = new bufferedreader(new inputstreamreader(p.geterrorstream())); 

  那么程序将发生阻塞，不能执行完成，而是hang在那里。
  当进程启动后，就会打开标准输出流和错误输出流准备输出，当进程结束时，就会关闭他们。在以上例子中，错误输出流没有数据要输出，标准输出流中有数据输出。由于标准输出流中的数据没有被读取，进程就不会结束，错误输出流也就不会被关闭，因此在调用readline()方法时，整个程序就会被阻塞。为了解决这个问题，可以根据输出的实际先后，先读取标准输出流，然后读取错误输出流。
   但是，很多时候不能很明确的知道输出的先后，特别是要操作标准输入的时候，情况就会更为复杂。这时候可以采用线程来对标准输出、错误输出和标准输入进行分别处理，根据他们之间在业务逻辑上的关系决定读取那个流或者写入数据。
   针对标准输出流和错误输出流所造成的问题，可以使用processbuilder的redirecterrorstream()方法将他们合二为一，这时候只要读取标准输出的数据就可以了。
当在程序中使用process的waitfor()方法时，特别是在读取之前调用waitfor()方法时，也有可能造成阻塞。可以用线程的方法来解决这个问题，也可以在读取数据后，调用waitfor()方法等待程序结束。
总之，解决阻塞的方法在这里我介绍使用processbuilder类，利用redirecterrorstream方法将标准输出流和错误输出流合二为一，在用start()方法启动进程后，先从标准输出中读取数据，然后调用waitfor()方法等待进程结束。
如：

import java.io.bufferedreader; 
import java.io.file; 
import java.io.inputstreamreader; 
import java.util.arraylist; 
import java.util.list; 
 
public class test3 { 
public static void main(string[] args) { 
  try { 
  list<string> list = new arraylist<string>(); 
  processbuilder pb = null; 
  process p = null; 
  string line = null; 
  bufferedreader stdout = null; 
  //list the files and directorys under c:\ 
  list.add("cmd.exe"); 
  list.add("/c"); 
  list.add("dir1"); 
  pb = new processbuilder(list); 
  pb.directory(new file("c:\\")); 
  //merge the error output with the standard output 
  pb.redirecterrorstream(true); 
  p = pb.start(); 
  //read the standard output 
  stdout = new bufferedreader(new inputstreamreader(p 
   .getinputstream())); 
  while ((line = stdout.readline()) != null) { 
   system.out.println(line); 
  } 
  int ret = p.waitfor(); 
  system.out.println("the return code is " + ret); 
  stdout.close(); 
  } catch (exception e) { 
  e.printstacktrace(); 
  } 
}