Package org.jgroups.util

Class BlockingInputStream

  • All Implemented Interfaces:
    java.io.Closeable, java.lang.AutoCloseable
    public class BlockingInputStream
extends java.io.InputStream
    Bounded input stream. A consumer reads bytes until the end of the stream is reached, or the input stream is closed. The producer writes bytes to the tail and blocks if the capacity has been reached (until the consumer reads more bytes).

    This class is for only 1 producer and 1 consumer; multiple producers/consumers will most likely yield incorrect results !

    Note that the implementation of this class is optimized for reading and adding a few K at a time; performance will be suboptimal if single bytes are added and read.

    Since:
    2.12.2
    Author:
    Bela Ban

    • Field Summary

      Fields 
      Modifier and Type Field Description
      protected byte[] buf
      The transfer buffer
      protected boolean closed
      Set to true when close() is called
      protected java.util.concurrent.locks.Lock lock  
      protected java.util.concurrent.locks.Condition not_empty
      Signalled when the buf becomes 'readable'; ie.
      protected java.util.concurrent.locks.Condition not_full
      Signalled when the buf becomes 'writeable'; ie.
      protected int read_pos
      Index into buf at which the next bytes will be read.
      protected int write_pos
      Index into buf at which bytes will be written.

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      int available()  
      int capacity()  
      void close()
      Closes the stream.
      protected void compact()
      Moves the bytes between [read_pos and write_pos] read_pos bytes to the left, such that the new read_pos is 0 and the write_pos is write_pos - read_pos.
      boolean isClosed()  
      int read()  
      int read​(byte[] b)  
      int read​(byte[] b, int off, int len)  
      protected int remaining()  
      protected static void sanityCheck​(byte[] buf, int offset, int length)
      Verifies that length doesn't exceed a buffer's length
      protected int size()  
      long skip​(long n)  
      java.lang.String toString()  
      void write​(byte[] buf)
      Appends bytes to the end of the stream
      void write​(byte[] buf, int offset, int length)
      Appends bytes to the end of the stream.

      • Methods inherited from class java.io.InputStream

        mark, markSupported, nullInputStream, readAllBytes, readNBytes, readNBytes, reset, transferTo

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

    • Field Detail

      • closed

        protected boolean closed
        Set to true when close() is called

      • buf

        protected final byte[] buf
        The transfer buffer

      • read_pos

        protected int read_pos
        Index into buf at which the next bytes will be read. Has to be between 0 and buf.length-1

      • write_pos

        protected int write_pos
        Index into buf at which bytes will be written. Has to be between 0 and buf.length-1

      • lock

        protected final java.util.concurrent.locks.Lock lock

      • not_full

        protected final java.util.concurrent.locks.Condition not_full
        Signalled when the buf becomes 'writeable'; ie. is not full anymore

      • not_empty

        protected final java.util.concurrent.locks.Condition not_empty
        Signalled when the buf becomes 'readable'; ie. is not empty anymore

    • Constructor Detail

      • BlockingInputStream

        public BlockingInputStream()

      • BlockingInputStream

        public BlockingInputStream​(int capacity)

    • Method Detail

      • read

        public int read()
         throws java.io.IOException
        Specified by:
        read in class java.io.InputStream
        Throws:
        java.io.IOException

      • read

        public int read​(byte[] b)
         throws java.io.IOException
        Overrides:
        read in class java.io.InputStream
        Throws:
        java.io.IOException

      • read

        public int read​(byte[] b,
                int off,
                int len)
         throws java.io.IOException
        Overrides:
        read in class java.io.InputStream
        Throws:
        java.io.IOException

      • write

        public void write​(byte[] buf)
           throws java.io.IOException
        Appends bytes to the end of the stream
        Parameters:
        buf -
        Throws:
        java.io.IOException
        See Also:
        write(byte[],int,int)

      • write

        public void write​(byte[] buf,
                  int offset,
                  int length)
           throws java.io.IOException
        Appends bytes to the end of the stream. If the number of bytes to be written is greater than the remaining capacity, write() will block until the bytes can be added, or the stream is closed.

        This method will try to append partial buffers to the stream, e.g. if the remaining capacity is 2K, but the length of the buffer is 5K, 2K will be written and then write() will block until the remaining 3K can be added.

        Parameters:
        buf - The buffer to be added to the end of the stream
        offset - The offset within buf at which bytes are read
        length - The number of bytes to be added
        Throws:
        java.io.IOException

      • skip

        public long skip​(long n)
          throws java.io.IOException
        Overrides:
        skip in class java.io.InputStream
        Throws:
        java.io.IOException

      • available

        public int available()
              throws java.io.IOException
        Overrides:
        available in class java.io.InputStream
        Throws:
        java.io.IOException

      • capacity

        public int capacity()

      • close

        public void close()
           throws java.io.IOException
        Closes the stream. Writes to a closed stream will fail, reads will successfully read the bytes that are already in the buffer and then return -1 (EOF)
        Specified by:
        close in interface java.lang.AutoCloseable
        Specified by:
        close in interface java.io.Closeable
        Overrides:
        close in class java.io.InputStream
        Throws:
        java.io.IOException

      • isClosed

        public boolean isClosed()

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object

      • size

        protected int size()

      • remaining

        protected int remaining()

      • compact

        protected void compact()
        Moves the bytes between [read_pos and write_pos] read_pos bytes to the left, such that the new read_pos is 0 and the write_pos is write_pos - read_pos. Lock must be held.

      • sanityCheck

        protected static void sanityCheck​(byte[] buf,
                                  int offset,
                                  int length)
        Verifies that length doesn't exceed a buffer's length
        Parameters:
        buf -
        offset -
        length -