Deadlock while closing subprocess streams ????

Question

in my java application i need to run another process and read its streams. I've got a code which:
1.starts another process using Runtime.exec() method
2.starts new thread which listen on process input stream
3.starts new thread which listen on process error stream
4.starts new thread which waits for new elements in the queue and writes them to process input stream
5.in some particular situation I need to close that process. I just close streams therefore the process ends.
The code executed in separate threads for read input and error stream:
     private InputStream fStream;
     private void read() {
          byte[] bytes= new byte[BUFFER_SIZE];
          int read = 0;
          while (read >= 0) {
               try {
                    read= fStream.read(bytes);
                    if (read > 0) {
                         String text;
                         if (fEncoding != null) {
                              text = new String(bytes, 0, read, fEncoding);
                         } else {
                              text = new String(bytes, 0, read);
                         synchronized (this) {
                              if (isBuffered()) {
                                   fContents.append(text);
                              fireStreamAppended(text);
               } catch (IOException ioe) {
               } catch (NullPointerException e) {
                    return;
     }The code executed in separate thread for writes to process output stream:
      * The stream which is being written to (connected to system in).
     private OutputStream fStream;
      * The queue of output.
     private Vector fQueue;
      * The thread which writes to the stream.
     private Thread fThread;
      * A lock for ensuring that writes to the queue are contiguous
     private Object fLock;
     protected void write() {
          while (fThread != null) {
               while (!fQueue.isEmpty() && !fClosed) {
                    String text = (String)fQueue.firstElement();
                    fQueue.removeElementAt(0);
                    try {
                         fStream.write(text.getBytes());
                         fStream.flush();
                    } catch (IOException e) {
                         DebugPlugin.log(e);
               try {
                    synchronized(fLock) {
                         fLock.wait();
               } catch (InterruptedException e) {
          if (!fClosed) {
               try {
                   fStream.close();
               } catch (IOException e) {
                    DebugPlugin.log(e);
     }the problem appears when i asynchronously try close external process by closing its streams:
inputStream.close()
errorStrean.close()
outputStream.close()in this situation it is possible dedlock while closing inputStream when associated thread waits on read() method.
Also I tried to close output stream first:
outputStream.close()
inputStream.close()
errorStrean.close()but this time it is possible deadlock while closing output stream monitor when associated thread waits on flush() method and external process doesn't read stream.
I think it is a bug in java because there is no way to close process streams asynchronously. I use java 6 on windows platform

Answer 1

ejp wrote:
I just close streams therefore the process ends.No it doesn't. Where did you get that idea from? Closing the output stream might cause the process to end, but you still have to read its input and error streams till EOF in both cases (and then close them - when you have read the EOF in each case).
Instead of just closing the output stream, you might have to call Process.destroy(). It depends on the process.ok, thank you for the reply. i have modified my code. now i only close output stream. this causes my process to end and thread for reading output and error streams finishes after receiving EOF.
outputStream.close()but there is still possible deadlock while closing output stream. this because in some cases process i starts doesn't read its input and my thread for writing to output stream waits on flush() method.
of course it is good idea to use process.destroy() method to cause process to end but it doesn't work for me. the process i start is some kind of launcher which: sets environment, starts another process, redirects streams and finishes itself.. after that i don't have an access to process. i have only streams.
thanks for your for the replies. i'm afraid that there is no good solution for this kind of problem