FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

* java/io/PipedReader: Synchronize on "lock" instead of this.

Browse source 
From-SVN: r38731
This commit is contained in:
Bryce McKinlay 2001-01-05 23:30:50 +00:00 • committed by Bryce McKinlay
parent 75b7557d49
commit a7fabf19be
2 changed files with 130 additions and 114 deletions
Download patch file Download diff file Expand all files Collapse all files

6
libjava/ChangeLog
View file

@ -1,3 +1,7 @@
2001-01-06 Bryce McKinlay <bryce@albatross.co.nz>
* java/io/PipedReader: Synchronize on "lock" instead of this.
2001-01-05 Bryce McKinlay <bryce@albatross.co.nz> 2001-01-05 Bryce McKinlay <bryce@albatross.co.nz>
* java/lang/Thread.java: Update comment. * java/lang/Thread.java: Update comment.
@ -6,7 +10,7 @@
* java/io/PipedOutputStream: Updated to match new PipedInputStream. * java/io/PipedOutputStream: Updated to match new PipedInputStream.
* java/io/PipedReader: New implementation based on new * java/io/PipedReader: New implementation based on new
PipedInputStream. PipedInputStream.
* java/io/PipedWriter: Updated to match new PipedOutputStream. * java/io/PipedWriter: Updated to match new PipedReader.
2001-01-03 Tom Tromey <tromey@redhat.com> 2001-01-03 Tom Tromey <tromey@redhat.com>

238
libjava/java/io/PipedReader.java
View file

@ -141,54 +141,57 @@ public class PipedReader extends Reader
* put it here in order to support that bizarre recieve(int) * put it here in order to support that bizarre recieve(int)
* method. * method.
*/ */
synchronized void receive(char[] buf, int offset, int len) void receive(char[] buf, int offset, int len)
throws IOException throws IOException
{ {
if (closed) synchronized (lock)
throw new IOException ("Pipe closed"); {
if (closed)
throw new IOException ("Pipe closed");
int bufpos = offset; int bufpos = offset;
int copylen; 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. while (len > 0)
in = 0; {
try
// Figure out how many chars from buf can be copied without {
// overrunning out or going past the length of the buffer. while (in == out)
if (in < out) {
copylen = Math.min (len, out - in); // The pipe is full. Wake up any readers and wait for them.
else lock.notifyAll();
copylen = Math.min (len, buffer.length - in); 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 ();
}
// Copy chars until the pipe is filled, wrapping if neccessary. if (in < 0) // The pipe is empty.
System.arraycopy(buf, bufpos, buffer, in, copylen); in = 0;
len -= copylen;
bufpos += copylen; // Figure out how many chars from buf can be copied without
in += copylen; // overrunning out or going past the length of the buffer.
if (in == buffer.length) if (in < out)
in = 0; copylen = Math.min (len, out - in);
} else
// Notify readers that new data is in the pipe. copylen = Math.min (len, buffer.length - in);
notifyAll();
// 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 <code>close()/code> was called on this Piped * @exception IOException If <code>close()/code> was called on this Piped
* Reader. * Reader.
*/ */
public synchronized int read(char[] buf, int offset, int len) public int read(char[] buf, int offset, int len)
throws IOException throws IOException
{ {
if (source == null) synchronized (lock)
throw new IOException ("Not connected"); {
if (closed) if (source == null)
throw new IOException ("Pipe closed"); 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 // If the buffer is empty, wait until there is something in the pipe
// to read. // to read.
try try
{ {
while (in < 0) while (in < 0)
{ {
if (source.closed) if (source.closed)
return -1; return -1;
wait(); lock.wait();
} }
} }
catch (InterruptedException ix) catch (InterruptedException ix)
{ {
throw new InterruptedIOException(); 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); int total = 0;
offset += copylen; int copylen;
len -= copylen;
out += copylen; while (true)
total += copylen; {
// Figure out how many chars from the pipe can be copied without
if (out == buffer.length) // overrunning in or going past the length of buf.
out = 0; if (out < in)
copylen = Math.min (len, in - out);
if (out == in) else
{ copylen = Math.min (len, buffer.length - out);
// Pipe is now empty.
in = -1; System.arraycopy (buffer, out, buf, offset, copylen);
offset += copylen;
len -= copylen;
out += copylen;
total += copylen;
if (out == buffer.length)
out = 0; out = 0;
}
// If output buffer is filled or the pipe is empty, we're done. if (out == in)
if (len == 0 || in == -1) {
{ // Pipe is now empty.
// Notify any waiting Writer that there is now space in = -1;
// to write. out = 0;
notifyAll(); }
return total;
} // 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 // The JDK 1.3 implementation does not appear to check for the closed or
// unconnected stream conditions here. // unconnected stream conditions here.
if (in < 0) synchronized (lock)
return false; {
if (in < 0)
int count; return false;
if (out < in)
count = in - out; int count;
else if (out < in)
count = (buffer.length - out) - in; count = in - out;
else
return (count > 0); count = (buffer.length - out) - in;
return (count > 0);
}
} }
/** /**
@ -326,10 +335,13 @@ public class PipedReader extends Reader
* *
* @exception IOException If an error occurs * @exception IOException If an error occurs
*/ */
public synchronized void close() throws IOException public void close() throws IOException
{ {
closed = true; synchronized (lock)
// Wake any thread which may be in receive() waiting to write data. {
notifyAll(); closed = true;
// Wake any thread which may be in receive() waiting to write data.
lock.notifyAll();
}
} }
} }