private static class InMemoryRepository.ByteArrayReadableChannel extends java.lang.Object implements ReadableChannel
| Modifier and Type | Field and Description |
|---|---|
private int |
blockSize |
private byte[] |
data |
private boolean |
open |
private int |
position |
| Constructor and Description |
|---|
ByteArrayReadableChannel(byte[] buf,
int blockSize) |
| Modifier and Type | Method and Description |
|---|---|
int |
blockSize()
Get the recommended alignment for reads.
|
void |
close() |
boolean |
isOpen() |
long |
position()
Get the current position of the channel.
|
void |
position(long newPosition)
Seek the current position of the channel to a new offset.
|
int |
read(java.nio.ByteBuffer dst) |
void |
setReadAheadBytes(int b)
Recommend the channel maintain a read-ahead buffer.
|
long |
size()
Get the total size of the channel.
|
private final byte[] data
private final int blockSize
private int position
private boolean open
public int read(java.nio.ByteBuffer dst)
read in interface java.nio.channels.ReadableByteChannelpublic void close()
close in interface java.io.Closeableclose in interface java.lang.AutoCloseableclose in interface java.nio.channels.Channelpublic boolean isOpen()
isOpen in interface java.nio.channels.Channelpublic long position()
ReadableChannelposition in interface ReadableChannelpublic void position(long newPosition)
ReadableChannelposition in interface ReadableChannelnewPosition - position to move the channel to. The next read will start from
here. This should be a multiple of the ReadableChannel.blockSize().public long size()
ReadableChannelPrior to reading from a channel the size might not yet be known. Implementors may return -1 until after the first read method call. Once a read has been completed, the underlying file size should be available.
size in interface ReadableChannelpublic int blockSize()
ReadableChannelStarting a read at multiples of the blockSize is more efficient than starting a read at any other position. If 0 or -1 the channel does not have any specific block size recommendation.
Channels should not recommend large block sizes. Sizes up to 1-4 MiB may
be reasonable, but sizes above that may be horribly inefficient. The
DfsBlockCache favors the
alignment suggested by the channel rather than the configured size under
the assumption that reads are very expensive and the channel knows what
size is best to access it with.
blockSize in interface ReadableChannelpublic void setReadAheadBytes(int b)
ReadableChannel
A read-ahead buffer of approximately bufferSize in bytes may be
allocated and used by the channel to smooth out latency for read.
Callers can continue to read in smaller than bufferSize chunks.
With read-ahead buffering enabled read latency may fluctuate in a pattern
of one slower read followed by (bufferSize / readSize) - 1 fast
reads satisfied by the read-ahead buffer. When summed up overall time to
read the same contiguous range should be lower than if read-ahead was not
enabled, as the implementation can combine reads to increase throughput.
To avoid unnecessary IO callers should only enable read-ahead if the majority of the channel will be accessed in order.
Implementations may chose to read-ahead using asynchronous APIs or background threads, or may simply aggregate reads using a buffer.
This read ahead stays in effect until the channel is closed or the buffer size is set to 0.
setReadAheadBytes in interface ReadableChannelb - requested size of the read ahead buffer, in bytes.