Reader:
Reader比InputStream对流的操作加了锁,见源码的方法abstract public int read(char cbuf[], int off, int len),其中锁是protected Object lock。
package java.io;
public abstract class Reader implements Readable, Closeable {
/** The object used to synchronize operations on this stream. For efficiency, a character-stream object may use an object other than
* itself to protect critical sections. A subclass should therefore use the object in this field rather than this or a synchronized method.*/
protected Object lock;
/*** Creates a new character-stream reader whose critical sections will synchronize on the reader itself.*/
protected Reader() {
this.lock = this;
}
/** Creates a new character-stream reader whose critical sections will synchronize on the given object. */
protected Reader(Object lock) {
if (lock == null) {
throw new NullPointerException();
}
this.lock = lock;
}
/** Attempts to read characters into the specified character buffer.
* The buffer is used as a repository of characters as-is: the only changes made are the results of a put operation. No flipping or
rewinding of the buffer is performed. @return The number of characters added to the buffer, or -1 if this source of characters is at its end
* @since 1.5
*/
public int read(java.nio.CharBuffer target) throws IOException {
//...
}
/** Reads a single character. This method will block until a character is available, an I/O error occurs, or the end of the stream is reached.
* @return The character read, as an integer in the range 0 to 65535 (0x00-0xffff), or -1 if the end of the stream has been reached
*/
public int read() throws IOException {
//...
}
/** Reads characters into an array. This method will block until some input is available, an I/O error occurs, or the end of the stream is reached.
* @return The number of characters read, or -1 if the end of the stream has been reached */
public int read(char cbuf[]) throws IOException {
return read(cbuf, 0, cbuf.length);
}
/** Reads characters into a portion of an array. This method will block until some input is available, an I/O error occurs, or the end of the
* stream is reached.
* @return The number of characters read, or -1 if the end of the stream has been reached */
abstract public int read(char cbuf[], int off, int len) throws IOException;
/** Maximum skip-buffer size */
private static final int maxSkipBufferSize = 8192;
/** Skip buffer, null until allocated */
private char skipBuffer[] = null;
/** Skips characters. This method will block until some characters are available, an I/O error occurs, or the end of the stream is reached.
* @return The number of characters actually skipped
*/
public long skip(long n) throws IOException {
//...
}
/**Tells whether this stream is ready to be read.
* @return True if the next read() is guaranteed not to block for input, false otherwise. Note that returning false does not
guarantee that the next read will block.
*/
public boolean ready() throws IOException {
return false;
}
/**Tells whether this stream supports the mark() operation. The default implementation always returns false. Subclasses should override
* this method.
* @return true if and only if this stream supports the mark operation.
*/
public boolean markSupported() {
return false;
}
/** Marks the present position in the stream. Subsequent calls to reset() will attempt to reposition the stream to this point. Not all
* character-input streams support the mark() operation. */
public void mark(int readAheadLimit) throws IOException {
throw new IOException("mark() not supported");
}
/** Resets the stream. If the stream has been marked, then attempt to reposition it at the mark. If the stream has not been marked, then
* attempt to reset it in some way appropriate to the particular stream, for example by repositioning it to its starting point. Not all
* character-input streams support the reset() operation, and some support reset() without supporting mark().
*/
public void reset() throws IOException {
throw new IOException("reset() not supported");
}
/** Closes the stream and releases any system resources associated with it. Once the stream has been closed, further read(), ready(),
* mark(), reset(), or skip() invocations will throw an IOException. Closing a previously closed stream has no effect.
*/
abstract public void close() throws IOException;
}
Writer:
Writer比OutputStream对流的操作加了锁,见源码的方法write(String str, int off, int len),其中锁是protected Object lock。
package java.io;
public abstract class Writer implements Appendable, Closeable, Flushable {
/**Temporary buffer used to hold writes of strings and single characters */
private char[] writeBuffer;
/**Size of writeBuffer, must be >= 1*/
private final int writeBufferSize = 1024;
/** The object used to synchronize operations on this stream. For efficiency, a character-stream object may use an object other than
* itself to protect critical sections. A subclass should therefore use the object in this field rather than <tt>this</tt> or a synchronized method.
*/
protected Object lock;
/** Creates a new character-stream writer whose critical sections will synchronize on the writer itself.*/
protected Writer() {
this.lock = this;
}
/** Creates a new character-stream writer whose critical sections will synchronize on the given object.*/
protected Writer(Object lock) {
if (lock == null) {
throw new NullPointerException();
}
this.lock = lock;
}
/** Writes a single character. The character to be written is contained in the 16 low-order bits of the given integer value; the 16 high-order bits
* are ignored.*/
public void write(int c) throws IOException {
synchronized (lock) {
//...
}
}
/** Writes an array of characters.*/
public void write(char cbuf[]) throws IOException {
write(cbuf, 0, cbuf.length);
}
/**Writes a portion of an array of characters. */
abstract public void write(char cbuf[], int off, int len) throws IOException;
/** Writes a string.*/
public void write(String str) throws IOException {
write(str, 0, str.length());
}
/** Writes a portion of a string.*/
public void write(String str, int off, int len) throws IOException {
synchronized (lock) {
///...
}
}
/** Appends the specified character sequence to this writer.
* @return This writer
* @since 1.5
*/
public Writer append(CharSequence csq) throws IOException {
//...
}
/** Appends a subsequence of the specified character sequence to this writer.
* @return This writer
* @since 1.5
*/
public Writer append(CharSequence csq, int start, int end) throws IOException {
CharSequence cs = (csq == null ? "null" : csq);
write(cs.subSequence(start, end).toString());
return this;
}
/** Appends the specified character to this writer.
* @return This writer
* @since 1.5
*/
public Writer append(char c) throws IOException {
write(c);
return this;
}
/** Flushes the stream. If the stream has saved any characters from the various write() methods in a buffer, write them immediately to their
* intended destination. Then, if that destination is another character or byte stream, flush it. Thus one flush() invocation will flush all the
* buffers in a chain of Writers and OutputStreams. */
abstract public void flush() throws IOException;
/** Closes the stream, flushing it first. Once the stream has been closed, further write() or flush() invocations will cause an IOException to be
* thrown. Closing a previously closed stream has no effect. */
abstract public void close() throws IOException;
}
额外篇:Reader、Writer的UML和使用例子,点击打开链接