code: def read_many(self, start_sequence, min_count, max_count):
          
          check_not_negative(start_sequence, "sequence can't be smaller than 0")
          check_true(max_count >= min_count, "max count should be greater or equal to min count")
          check_true(min_count <= self.capacity().result(), "min count should be smaller or equal to capacity")
          check_true(max_count < MAX_BATCH_SIZE, "max count can't be greater than %d" % MAX_BATCH_SIZE)
  
          return self._encode_invoke(ringbuffer_read_many_codec, response_handler=self._read_many_response_handler,
                                     start_sequence=start_sequence, min_count=min_count,
                                     max_count=max_count, filter=None)
docs: Reads a batch of items from the Ringbuffer. If the number of available items after the first read item is
          smaller than the max_count, these items are returned. So it could be the number of items read is smaller than
          the max_count. If there are less items available than min_count, then this call blocks. Reading a batch of items
          is likely to perform better because less overhead is involved.
  
          :param start_sequence: (long),  the start_sequence of the first item to read.
          :param min_count: (int), the minimum number of items to read.
          :param max_count: (int), the maximum number of items to read.
          :return: (Sequence), the list of read items.