Package com.google.cloud.storage.contrib.nio

Class SeekableByteChannelPrefetcher

java.lang.Object
com.google.cloud.storage.contrib.nio.SeekableByteChannelPrefetcher
All Implemented Interfaces:
Closeable, AutoCloseable, ByteChannel, Channel, ReadableByteChannel, SeekableByteChannel, WritableByteChannel
public final class SeekableByteChannelPrefetcher extends Object implements SeekableByteChannel
SeekableByteChannelPrefetcher wraps an existing SeekableByteChannel to add prefetching. The prefetching is done on a different thread, so you can write simple code that repeatedly calls read() to get data, processes it, and then calls read again -- and yet this simple code overlaps computation and communication for you. (Of course this is only worthwhile if the underlying SeekableByteChannel doesn't already implement prefetching).

  • Method Details

    • addPrefetcher

      public static SeekableByteChannel addPrefetcher(int bufferSizeMB, SeekableByteChannel channel) throws IOException
      Wraps the provided SeekableByteChannel within a SeekableByteChannelPrefetcher, using the provided buffer size
      Parameters:
      bufferSizeMB - buffer size in MB
      channel - channel to wrap in the prefetcher
      Returns:
      wrapped channel
      Throws:
      IOException

    • getStatistics

      public SeekableByteChannelPrefetcher.Statistics getStatistics()

    • fetch

      public ByteBuffer fetch(long position) throws InterruptedException, ExecutionException
      Throws:
      InterruptedException
      ExecutionException

    • read

      public int read(ByteBuffer dst) throws IOException
      Reads a sequence of bytes from this channel into the given buffer.

      Bytes are read starting at this channel's current position, and then the position is updated with the number of bytes actually read. Otherwise this method behaves exactly as specified in the ReadableByteChannel interface.

      Specified by:
      read in interface ReadableByteChannel
      Specified by:
      read in interface SeekableByteChannel
      Parameters:
      dst - buffer to write into
      Throws:
      IOException

    • write

      public int write(ByteBuffer src) throws IOException
      Writing isn't supported.
      Specified by:
      write in interface SeekableByteChannel
      Specified by:
      write in interface WritableByteChannel
      Throws:
      IOException

    • position

      public long position() throws IOException
      Returns this channel's position.
      Specified by:
      position in interface SeekableByteChannel
      Returns:
      This channel's position, a non-negative integer counting the number of bytes from the beginning of the entity to the current position
      Throws:
      ClosedChannelException - If this channel is closed
      IOException - If some other I/O error occurs

    • position

      public SeekableByteChannel position(long newPosition) throws IOException
      Sets this channel's position.

      Setting the position to a value that is greater than the current size is legal but does not change the size of the entity. A later attempt to read bytes at such a position will immediately return an end-of-file indication. A later attempt to write bytes at such a position will cause the entity to grow to accommodate the new bytes; the values of any bytes between the previous end-of-file and the newly-written bytes are unspecified.

      Setting the channel's position is not recommended when connected to an entity, typically a file, that is opened with the APPEND option. When opened for append, the position is first advanced to the end before writing.

      Specified by:
      position in interface SeekableByteChannel
      Parameters:
      newPosition - The new position, a non-negative integer counting the number of bytes from the beginning of the entity
      Returns:
      This channel
      Throws:
      ClosedChannelException - If this channel is closed
      IllegalArgumentException - If the new position is negative
      IOException - If some other I/O error occurs

    • size

      public long size() throws IOException
      Returns the current size of entity to which this channel is connected.
      Specified by:
      size in interface SeekableByteChannel
      Returns:
      The current size, measured in bytes
      Throws:
      ClosedChannelException - If this channel is closed
      IOException - If some other I/O error occurs

    • truncate

      public SeekableByteChannel truncate(long size) throws IOException
      Not supported.
      Specified by:
      truncate in interface SeekableByteChannel
      Throws:
      IOException

    • isOpen

      public boolean isOpen()
      Tells whether or not this channel is open.
      Specified by:
      isOpen in interface Channel
      Returns:
      true if, and only if, this channel is open

    • close

      public void close() throws IOException
      Closes this channel.

      After a channel is closed, any further attempt to invoke I/O operations upon it will cause a ClosedChannelException to be thrown.

      If this channel is already closed then invoking this method has no effect.

      This method may be invoked at any time. If some other thread has already invoked it, however, then another invocation will block until the first invocation is complete, after which it will return without effect.

      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Channel
      Specified by:
      close in interface Closeable
      Throws:
      IOException - If an I/O error occurs