class  PipeThread  implements  Runnable {

    InputStream m_in;
    OutputStream m_out;
    PipeThread(InputStream in, OutputStream out) {
         super ();
        m_in = in;
        m_out = out;
    }
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p/>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see Thread#run()
     */
     public   void  run() {
         int  c;
         try  {
             while  ( (c = m_in.read()) >  0 ) {
                m_out.write(c);
            }
            m_out.flush();
            m_out.close();
        }  catch  (IOException e) {
            e.printStackTrace();
        }
    }
}

/**
 * @author knu
 */
 public   class  MyRuntime {

     public  InputStream exec2stream( final  String cmd)  throws  MyException {
        PipedInputStream result =  new  PipedInputStream();
        java.lang.Runtime rt;
        Process proc;
        ByteArrayOutputStream err =  new  ByteArrayOutputStream();
         try  {
            PipedOutputStream out =  new  PipedOutputStream(result);
            rt = Runtime.getRuntime();
            proc = rt.exec(cmd);
            Thread tin =  new  Thread(
                 new  PipeThread(proc.getInputStream(), out)
            );
            Thread terr =  new  Thread(
                 new  PipeThread(proc.getErrorStream(), err)
            );
            tin.start();
            terr.start();
//            proc.waitFor();
        }  catch  (Throwable t) {
             throw   new  MyException(t.toString());
        }
         if  (err.size() >  0 ) {
             throw   new  MyException( new  String(err.toByteArray()));
        }
         return  result;
    }

     public   void  exec( final  String cmd)  throws  MyException {
        InputStream in = exec2stream(cmd);
         try  {
             int  c =  0 ;
             while  ( (c = in.read()) >  0 ) { /*something*/ };
        }  catch  (Throwable t) {
             throw   new  MyException(t.toString());
        }  finally  {
             try  {
                in.close();
            }  catch  (IOException e) {
                 throw   new  MyException(e);
            }
        }
    }
}