解决Process.getInputStream()阻塞的问题

process.getinputstream()阻塞问题

java中

runtime.getinstance().exec (string cmd)

或者

new processbuilder(string cmd).start()

都可以产生子进程对象process。通过调用process对象的waitfor()方法可以使主进程进入等待状态，直至子进程执行完毕，再进行下一步工作。如果对子进程处理不当，有可能造成主进程阻塞，整个程序死掉。

java api中关于process说的是：

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

创建进程的方法可能无法针对某些本机平台上的特定进程很好地工作，比如，本机窗口进程，守护进程，microsoft windows 上的 win16/dos 进程，或者 shell 脚本。创建的子进程没有自己的终端或控制台。它的所有标准 io（即 stdin，stdout，stderr）操作都将通过三个流 (getoutputstream()，getinputstream()，geterrorstream()) 重定向到父进程。父进程使用这些流来提供到子进程的输入和获得从子进程的输出。因为有些本机平台仅针对标准输入和输出流提供有限的缓冲区大小，如果读写子进程的输出流或输入流迅速出现失败，则可能导致子进程阻塞，甚至产生死锁。

在对getoutputstream()，getinputstream()，geterrorstream()的描述中，有个注意事项：对其输出流和错误流进行缓冲是一个好主意！嗯，好抽象啊！

问题正在于此，process.getinputstream()和process.geterrorstream()分别返回process的标准输出流和错误流，两个流如果处理不当，其缓冲区不能被及时清除而被塞满，则进程被阻塞，即使调用process.destory()也未必能销毁被阻塞的子进程。

如果尝试同步获取process的输出流和错误流进行处理，未必有效，顺序执行过程中，输出流和错误流常常不能得到及时处理。解决方案有两个。

方案一：并发获取process的输出流和错误流

通过启动两个线程来并发地读取和处理输出流和错误流，懒得打开ide了，就大概敲一下代码吧，可能有错误，如下：

调用者：

class processexecutor
{
 private process p;
 private list<string> outputlist;
 private list<string> erroroutputlist;
 public processexecutor(process p) throws ioexception
 {
  if(null == p)
  {
   throw new ioexception("the provided process is null");
  }
  this. p = p;
 }
 public list<string> getoutputlist()
 {
  return this. outputlist;
 }
 public list<string> geterroroutputlist()
 {
  return this.erroroutputlist;
 }
 public int execute()
 {
  int rs = 0;
  thread outputthread = new processoutputthread(this.p.getinputstream());
  thread erroroutputthread = new processoutputthread(this.p.geterrorstream());
  outputthread.start();
  erroroutputthread.start();
  rs = p.waitfor();
  outputthread.join();
  erroroutputthread.join();
  this.outputlist = outputthread.getoutputlist();
  this.erroroutputlist = erroroutputthread.getoutputlist();
  return rs;
 }
}

流处理线程

class processoutputthread extends thread
{
 private inputstream is;
 private list<string> outputlist;
 public processoutputthread(inputstream is) throws ioexception
 {
  if(null == is)
  {
   throw new ioexception("the provided inputstream is null");
  }
  this. is = is;
  this.outputlist = new arraylist<string>();
 }
 public list<string> getoutputlist()
 {
  return this. outputlist;
 }
 @override
 public void run()
 {
  inputstreamreader ir = null;
  bufferedreader br = null;
  try
  {
   ir = new inputstreamreader(this.is);
   br = new bufferedreader(ir);
   string output = null;
   while(null != (output = br.readline()))
   {
    print(output);
    this.outputlist.add(output);
   }
  }
  catch(ioexception e)
  {
   e.print();
  }
  finally
  (
   try
   {
    if(null != br)
    {
     br.close();
    }
    if(null != ir)
    {
     ir.close();
    }
    if(null != this.is)
    {
     this.is.close();
    }
   }
   catch(ioexception e)
   {
    e.print();
   }
  )
 }
}

方案二：用processbuilder的redirecterrorstream()方法合并输出流和错误流

public int execute()
{
 int rs = 0;
 string[] cmds = {...};//command and arg  
 processbuilder builder = new processbuilder(cmds);  
 builder.redirecterrorstream(true);  
 process process = builder.start();  
 bufferedreader br = new bufferedreader(new inputstreamreader(process.getinputstream()));  
 string output = null;  
 while (null != (readline = br.readline()))
 {  
     print(output);   
 }  
 rs = process.waitfor();
 return rs;
} 

java process 阻塞测试总结

process阻塞原因：输入流和错误流分开的，没有处理，就会发生阻塞，归根结底本质上是bio引起的io阻塞问题。

getinputstream,geterrorsteam就是获取脚本或者命令的控制台回显信息，前者获取的是标准输出的回显信息，后者获取的是标准错误的回显信息

process原理：使用runtime.getruntime().exec(cmd)会在当前进程建立一个子进程，子进程由于没有控制台，它的标准输出和标准错误就会返回给父进程process，因此通过getinputstream和geterrorstream就可以获取到这些信息。

测试代码如下：

import java.io.bufferedreader;
import java.io.ioexception;
import java.io.inputstream;
import java.io.inputstreamreader;
public class javaexebat {
        public javaexebat() {
        }
        public static void main(string[] args) {
                process p;
                //test.bat中的命令是ipconfig/all
                string cmd="sh test.sh ";
                //string cmd="ping 127.0.0.1 -c 4";
 
                try {
                        //执行命令
                        p = runtime.getruntime().exec(cmd);
                        //取得命令结果的输出流
                        //输出流
                        inputstream fis=p.getinputstream();
                        //错误流
                        inputstream ferrs=p.geterrorstream();
                        //用一个读输出流类去读
                        inputstreamreader isr=new inputstreamreader(fis);
                        inputstreamreader errsr=new inputstreamreader(ferrs);
                        //用缓冲器读行
                        bufferedreader br=new bufferedreader(isr);
                        bufferedreader errbr=new bufferedreader(errsr);
                        string line=null;
                        string lineerr = null;
                        //直到读完为止
                        while((line=br.readline())!=null) {
                        //有可能发生阻塞的问题
                                system.out.println("return input str:" + line);
                        }
                        while((lineerr=errbr.readline())!=null){
                        //有可能发生阻塞的问题
                                system.out.println("return err str:" + lineerr);
                        }
                        int exitval = p.waitfor();
                        system.out.println("exitval:" + exitval);
                } catch (exception e) {
                        e.printstacktrace();
                }
        }
}

test.sh如下

#!/bin/bash
 
for((i=0; i < 100000; i++));do
         //输出的标准输出
        echo "testaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
        //输出到标准错误
        echo "testaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 1>&2
done

经过测试发现，如果javaexebat.java文件中只开启标准输出或者标准错误时，进程就会夯住，无法通过waitefor获取其返回值，因为脚本中分别输出了100000w条信息到标准输出和标准错误，而下述代码只处理了getinputstream，导致标准错误输出流的信息太多返回给当前进程，没有得到处理，因此阻塞。

代码如下：

p = runtime.getruntime().exec(cmd);
                        //取得命令结果的输出流
                        //输出流
                        inputstream fis=p.getinputstream();
                        //用一个读输出流类去读
                        inputstreamreader isr=new inputstreamreader(fis);
                        //用缓冲器读行
                        bufferedreader br=new bufferedreader(isr);
                        string line=null;
                        //直到读完为止
                        while((line=br.readline())!=null) {
                        //有可能发生阻塞的问题
                                system.out.println("return input str:" + line);
                        }
                        int exitval = p.waitfor();
                        system.out.println("exitval:" + exitval);

把上述代码中的getinputstream换做geterrorstream，也会夯住进程，因为同样只处理了两者中一者，即标准错误。

那么能不能同步处理两个流信息呢？代码如下：

try {
                        //执行命令
                        p = runtime.getruntime().exec(cmd);
                        //取得命令结果的输出流
                        //输出流
                        inputstream fis=p.getinputstream();
                        //错误流
                        inputstream ferrs=p.geterrorstream();
                        //用一个读输出流类去读
                        inputstreamreader isr=new inputstreamreader(fis);
                        inputstreamreader errsr=new inputstreamreader(ferrs);
                        //用缓冲器读行
                        bufferedreader br=new bufferedreader(isr);
                        bufferedreader errbr=new bufferedreader(errsr);
                        string line=null;
                        string lineerr = null;
                        //直到读完为止
                        while((line=br.readline())!=null) {
                        //有可能发生阻塞的问题
                                system.out.println("return input str:" + line);
                        }
                        while((lineerr=errbr.readline())!=null){
                        //有可能发生阻塞的问题
                                system.out.println("return err str:" + lineerr);
                        }
                        int exitval = p.waitfor();
                        system.out.println("exitval:" + exitval);
                } catch (exception e) {
                        e.printstacktrace();
                }
        }

测试过后发现也不行，因为是同步的，就会有先后顺序，也会发生阻塞，测试方法，将test.sh改为只打印标准错误，就会发现标准错误处理被阻塞，脚本如下：

#!/bin/bash
 
for((i=0; i < 100000; i++));do
        //输出到标准错误
        echo "testaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 1>&2
done

解决办法思路：

（1）并发处理两个流信息，开启两个线程分别处理输出流与错误流

（2）将两个流合并为一个流解决示例：

第一种思路：

class processexecutor  
    {  
        private process p;  
        private list<string> outputlist;  
        private list<string> erroroutputlist;  
        public processexecutor(process p) throws ioexception  
        {  
            if(null == p)  
            {  
                throw new ioexception("the provided process is null");  
            }  
            this. p = p;  
        }  
        public list<string> getoutputlist()  
        {  
            return this. outputlist;  
        }  
        public list<string> geterroroutputlist()  
        {  
            return this.erroroutputlist;  
        }  
        public int execute()  
        {  
            int rs = 0;  
            thread outputthread = new processoutputthread(this.p.getinputstream());  
            thread erroroutputthread = new processoutputthread(this.p.geterrorstream());  
            outputthread.start();  
            erroroutputthread.start();  
            rs = p.waitfor();  
            outputthread.join();  
            erroroutputthread.join();  
            this.outputlist = outputthread.getoutputlist();  
            this.erroroutputlist = erroroutputthread.getoutputlist();  
            return rs;  
        }  
    }  
    
    class processoutputthread extends thread  
    {  
        private inputstream is;  
        private list<string> outputlist;  
        public processoutputthread(inputstream is) throws ioexception  
        {  
            if(null == is)  
            {  
                throw new ioexception("the provided inputstream is null");  
            }  
            this. is = is;  
            this.outputlist = new arraylist<string>();  
        }  
        public list<string> getoutputlist()  
        {  
            return this. outputlist;  
        }  
        @override  
        public void run()  
        {  
            inputstreamreader ir = null;  
            bufferedreader br = null;  
            try  
            {  
                ir = new inputstreamreader(this.is);  
                br = new bufferedreader(ir);  
                string output = null;  
                while(null != (output = br.readline()))  
                {  
                    print(output);  
                    this.outputlist.add(output);  
                }  
            }  
            catch(ioexception e)  
            {  
                e.print();  
            }  
            finally  
            (  
                try  
                {  
                    if(null != br)  
                    {  
                        br.close();  
                    }  
                    if(null != ir)  
                    {  
                        ir.close();  
                    }  
                    if(null != this.is)  
                    {  
                        this.is.close();  
                    }  
                }  
                catch(ioexception e)  
                {  
                    e.print();  
                }  
            )  
        }  
    }  

第二种思路：使用processbuilder，将其redirecterrorstream(true)；将输出流与错误流合并

 public int execute()  
    {  
        int rs = 0;  
        string[] cmds = {...};//command and arg    
        processbuilder builder = new processbuilder(cmds);    
        builder.redirecterrorstream(true);    
        process process = builder.start();    
        bufferedreader br = new bufferedreader(new inputstreamreader(process.getinputstream()));    
        string output = null;    
        while (null != (readline = br.readline()))  
        {    
            print(output);     
        }    
        rs = process.waitfor();  
        return rs;  
    }  

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。