From a7fabf19be96544b4ff7729a326f220ba2e37a27 Mon Sep 17 00:00:00 2001 From: Bryce McKinlay Date: Fri, 5 Jan 2001 23:30:50 +0000 Subject: [PATCH] * java/io/PipedReader: Synchronize on "lock" instead of this. From-SVN: r38731 --- libjava/ChangeLog | 6 +- libjava/java/io/PipedReader.java | 248 ++++++++++++++++++++------------------- 2 files changed, 135 insertions(+), 119 deletions(-) diff --git a/libjava/ChangeLog b/libjava/ChangeLog index d0ae121..1f31191 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,7 @@ +2001-01-06 Bryce McKinlay + + * java/io/PipedReader: Synchronize on "lock" instead of this. + 2001-01-05 Bryce McKinlay * java/lang/Thread.java: Update comment. @@ -6,7 +10,7 @@ * java/io/PipedOutputStream: Updated to match new PipedInputStream. * java/io/PipedReader: New implementation based on new PipedInputStream. - * java/io/PipedWriter: Updated to match new PipedOutputStream. + * java/io/PipedWriter: Updated to match new PipedReader. 2001-01-03 Tom Tromey diff --git a/libjava/java/io/PipedReader.java b/libjava/java/io/PipedReader.java index 6e4e104..af37595 100644 --- a/libjava/java/io/PipedReader.java +++ b/libjava/java/io/PipedReader.java @@ -141,54 +141,57 @@ public class PipedReader extends Reader * put it here in order to support that bizarre recieve(int) * method. */ - synchronized void receive(char[] buf, int offset, int len) + void receive(char[] buf, int offset, int len) throws IOException { - if (closed) - throw new IOException ("Pipe closed"); + synchronized (lock) + { + if (closed) + throw new IOException ("Pipe closed"); - int bufpos = offset; - int copylen; - - while (len > 0) - { - try - { - while (in == out) - { - // The pipe is full. Wake up any readers and wait for them. - notifyAll(); - wait(); - // The pipe could have been closed while we were waiting. - if (closed) - throw new IOException ("Pipe closed"); - } - } - catch (InterruptedException ix) - { - throw new InterruptedIOException (); - } - - if (in < 0) // The pipe is empty. - in = 0; - - // Figure out how many chars from buf can be copied without - // overrunning out or going past the length of the buffer. - if (in < out) - copylen = Math.min (len, out - in); - else - copylen = Math.min (len, buffer.length - in); - - // Copy chars until the pipe is filled, wrapping if neccessary. - System.arraycopy(buf, bufpos, buffer, in, copylen); - len -= copylen; - bufpos += copylen; - in += copylen; - if (in == buffer.length) - in = 0; - } - // Notify readers that new data is in the pipe. - notifyAll(); + int bufpos = offset; + int copylen; + + while (len > 0) + { + try + { + while (in == out) + { + // The pipe is full. Wake up any readers and wait for them. + lock.notifyAll(); + lock.wait(); + // The pipe could have been closed while we were waiting. + if (closed) + throw new IOException ("Pipe closed"); + } + } + catch (InterruptedException ix) + { + throw new InterruptedIOException (); + } + + if (in < 0) // The pipe is empty. + in = 0; + + // Figure out how many chars from buf can be copied without + // overrunning out or going past the length of the buffer. + if (in < out) + copylen = Math.min (len, out - in); + else + copylen = Math.min (len, buffer.length - in); + + // Copy chars until the pipe is filled, wrapping if neccessary. + System.arraycopy(buf, bufpos, buffer, in, copylen); + len -= copylen; + bufpos += copylen; + in += copylen; + if (in == buffer.length) + in = 0; + } + // Notify readers that new data is in the pipe. + lock.notifyAll(); + } } /** @@ -240,84 +243,90 @@ public class PipedReader extends Reader * @exception IOException If close()/code> was called on this Piped * Reader. */ - public synchronized int read(char[] buf, int offset, int len) + public int read(char[] buf, int offset, int len) throws IOException { - if (source == null) - throw new IOException ("Not connected"); - if (closed) - throw new IOException ("Pipe closed"); - - // If the buffer is empty, wait until there is something in the pipe - // to read. - try - { - while (in < 0) - { - if (source.closed) - return -1; - wait(); - } - } - catch (InterruptedException ix) - { - throw new InterruptedIOException(); - } - - int total = 0; - int copylen; - - while (true) - { - // Figure out how many chars from the pipe can be copied without - // overrunning in or going past the length of buf. - if (out < in) - copylen = Math.min (len, in - out); - else - copylen = Math.min (len, buffer.length - out); - - System.arraycopy (buffer, out, buf, offset, copylen); - offset += copylen; - len -= copylen; - out += copylen; - total += copylen; - - if (out == buffer.length) - out = 0; - - if (out == in) - { - // Pipe is now empty. - in = -1; + synchronized (lock) + { + if (source == null) + throw new IOException ("Not connected"); + if (closed) + throw new IOException ("Pipe closed"); + + // If the buffer is empty, wait until there is something in the pipe + // to read. + try + { + while (in < 0) + { + if (source.closed) + return -1; + lock.wait(); + } + } + catch (InterruptedException ix) + { + throw new InterruptedIOException(); + } + + int total = 0; + int copylen; + + while (true) + { + // Figure out how many chars from the pipe can be copied without + // overrunning in or going past the length of buf. + if (out < in) + copylen = Math.min (len, in - out); + else + copylen = Math.min (len, buffer.length - out); + + System.arraycopy (buffer, out, buf, offset, copylen); + offset += copylen; + len -= copylen; + out += copylen; + total += copylen; + + if (out == buffer.length) out = 0; - } - - // If output buffer is filled or the pipe is empty, we're done. - if (len == 0 || in == -1) - { - // Notify any waiting Writer that there is now space - // to write. - notifyAll(); - return total; - } - } + + if (out == in) + { + // Pipe is now empty. + in = -1; + out = 0; + } + + // If output buffer is filled or the pipe is empty, we're done. + if (len == 0 || in == -1) + { + // Notify any waiting Writer that there is now space + // to write. + lock.notifyAll(); + return total; + } + } + } } - public synchronized boolean ready() throws IOException + public boolean ready() throws IOException { // The JDK 1.3 implementation does not appear to check for the closed or // unconnected stream conditions here. - if (in < 0) - return false; - - int count; - if (out < in) - count = in - out; - else - count = (buffer.length - out) - in; - - return (count > 0); + synchronized (lock) + { + if (in < 0) + return false; + + int count; + if (out < in) + count = in - out; + else + count = (buffer.length - out) - in; + + return (count > 0); + } } /** @@ -326,10 +335,13 @@ public class PipedReader extends Reader * * @exception IOException If an error occurs */ - public synchronized void close() throws IOException + public void close() throws IOException { - closed = true; - // Wake any thread which may be in receive() waiting to write data. - notifyAll(); + synchronized (lock) + { + closed = true; + // Wake any thread which may be in receive() waiting to write data. + lock.notifyAll(); + } } } -- 2.7.4