Rapid array accesses and garbage collection

I have a small app that uses an Array as a queue. Works well enough but
(seems) to suffer from GC lockouts

Items are added and removed (<< and shift) from the Array frequently and
the queue itself rarely gets very large, 10s to 100s of records, but the
throughput is 100,000s of records

Which is, I assume, causing it to periodically freeze. The question is:

1) Should I manually start GC after every shift operation. Will this trade
off frequent small GC interruptions for less big freezes
2) Should I manually start GC after X shifts. Will large GC events be more
3) Should I create a fake Array such as below and have much larger GC events

Any pointers or will it just be trying stuff and measuring?

class SlowArray

  def initialize
    @data = []
    @size = 0
    @read_from = 0

  def <<(value)
    @data << value
    @size += 1

  def shift
    if @size == 0
      return nil
      x = @data[@read_from]
      @read_from += 1

      if @read_from == DEAD_ZONE
        @data = @data[DEAD_ZONE..-1]
        @read_from = 0

      @size -= 1
      return x

  def size

For reference, frequent small GC runs stops the long freeze-up that can
occur but slows down the throughput