class Thread::SizedQueue - Documentation for Ruby 4.1
Description: class Thread::SizedQueue: This class represents queues of specified size capacity. The push operation may be blocked if the capacity is full.
Keywords: ruby,class,Thread::SizedQueue

🔍

No recent searches

# class Thread::SizedQueue

This class represents queues of specified size capacity. The push operation may be blocked if the capacity is full.

See `Thread::Queue` for an example of how a `Thread::SizedQueue` works.

### Public Class Methods

new(max)
Source

    # File thread_sync.rb, line 198
    def initialize(vmax)
      Primitive.szqueue_initialize(vmax)
    end

Creates a fixed-length queue with a maximum size of `max`.

### Public Instance Methods

<<(object)
Alias for: push
clear ()
Source

    # File thread_sync.rb, line 268
    def clear
      Primitive.cstmt! %{
        struct rb_szqueue *sq = szqueue_ptr(self);
        queue_clear(&sq->q);
        wakeup_all(szqueue_pushq(sq));
        return self;
      }
    end

Removes all objects from the queue.

close
Source

    # File thread_sync.rb, line 254
    def close
      Primitive.cstmt! %{
        if (!queue_closed_p(self)) {
            struct rb_szqueue *sq = szqueue_ptr(self);

            FL_SET(self, QUEUE_CLOSED);
            wakeup_all(szqueue_waitq(sq));
            wakeup_all(szqueue_pushq(sq));
        }
        return self;
      }
    end

Similar to `Thread::Queue#close`.

The difference is behavior with waiting enqueuing threads.

If there are waiting enqueuing threads, they are interrupted by raising ClosedQueueError(‘queue closed’).

deq
Alias for: pop
enq(object, non_block=false, timeout: nil)
Alias for: push
max ()
Source

    # File thread_sync.rb, line 286
    def max
      Primitive.cexpr!('LONG2NUM(szqueue_ptr(self)->max)')
    end

Returns the maximum size of the queue.

max=(number)
Source

    # File thread_sync.rb, line 293
    def max=(vmax)
      Primitive.cstmt! %{
        long max = NUM2LONG(vmax);
        if (max <= 0) {
            rb_raise(rb_eArgError, "queue size must be positive");
        }

        long diff = 0;
        struct rb_szqueue *sq = szqueue_ptr(self);

        if (max > sq->max) {
            diff = max - sq->max;
        }
        sq->max = max;
        sync_wakeup(szqueue_pushq(sq), diff);
        return vmax;
      }
    end

Sets the maximum size of the queue to the given `number`.

num_waiting ()
Source

    # File thread_sync.rb, line 278
    def num_waiting
      Primitive.cstmt! %{
        struct rb_szqueue *sq = szqueue_ptr(self);
        return INT2NUM(sq->q.num_waiting + sq->num_waiting_push);
      }
    end

Returns the number of threads waiting on the queue.

pop(non_block=false, timeout: nil)
Source

    # File thread_sync.rb, line 213
    def pop(non_block = false, timeout: nil)
      if non_block && timeout
        raise ArgumentError, "can't set a timeout if non_block is enabled"
      end
      Primitive.rb_szqueue_pop(non_block, timeout)
    end

Retrieves data from the queue.

If the queue is empty, the calling thread is suspended until data is pushed onto the queue. If `non_block` is true, the thread isn’t suspended, and `ThreadError` is raised.

If `timeout` seconds have passed and no data is available `nil` is returned. If `timeout` is `0` it returns immediately.

Also aliased as: deq, shift
push(object, non_block=false, timeout: nil)
Source

    # File thread_sync.rb, line 236
    def push(object, non_block = false, timeout: nil)
      if non_block && timeout
        raise ArgumentError, "can't set a timeout if non_block is enabled"
      end
      Primitive.rb_szqueue_push(object, non_block, timeout)
    end

Pushes `object` to the queue.

If there is no space left in the queue, waits until space becomes available, unless `non_block` is true. If `non_block` is true, the thread isn’t suspended, and `ThreadError` is raised.

If `timeout` seconds have passed and no space is available `nil` is returned. If `timeout` is `0` it returns immediately. Otherwise it returns `self`.

Also aliased as: enq, <<
shift
Alias for: pop