Support for the Ruby 2.4 series has ended. See here for reference.

In Files

  • thread_sync.c

Class/Module Index [+]

Quicksearch

SizedQueue

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

See Queue for an example of how a SizedQueue works.

Public Class Methods

new(max) click to toggle source

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

 
               static VALUE
rb_szqueue_initialize(VALUE self, VALUE vmax)
{
    long max;

    max = NUM2LONG(vmax);
    if (max <= 0) {
        rb_raise(rb_eArgError, "queue size must be positive");
    }

    RSTRUCT_SET(self, QUEUE_QUE, ary_buf_new());
    RSTRUCT_SET(self, QUEUE_WAITERS, ary_buf_new());
    RSTRUCT_SET(self, SZQUEUE_WAITERS, ary_buf_new());
    RSTRUCT_SET(self, SZQUEUE_MAX, vmax);

    return self;
}
            

Public Instance Methods

<<(*args) click to toggle source
Alias for: push
clear() click to toggle source

Removes all objects from the queue.

 
               static VALUE
rb_szqueue_clear(VALUE self)
{
    rb_ary_clear(GET_QUEUE_QUE(self));
    wakeup_all_threads(GET_SZQUEUE_WAITERS(self));
    return self;
}
            
close click to toggle source

Similar to Queue#close.

The difference is behavior with waiting enqueuing threads.

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

 
               static VALUE
rb_szqueue_close(VALUE self)
{
    return queue_do_close(self, TRUE);
}
            
deq(*args) click to toggle source
Alias for: pop
enq(*args) click to toggle source
Alias for: push
max() click to toggle source

Returns the maximum size of the queue.

 
               static VALUE
rb_szqueue_max_get(VALUE self)
{
    return GET_SZQUEUE_MAX(self);
}
            
max=(number) click to toggle source

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

 
               static VALUE
rb_szqueue_max_set(VALUE self, VALUE vmax)
{
    long max = NUM2LONG(vmax), diff = 0;
    VALUE t;

    if (max <= 0) {
        rb_raise(rb_eArgError, "queue size must be positive");
    }
    if ((unsigned long)max > GET_SZQUEUE_ULONGMAX(self)) {
        diff = max - GET_SZQUEUE_ULONGMAX(self);
    }
    RSTRUCT_SET(self, SZQUEUE_MAX, vmax);
    while (diff-- > 0 && !NIL_P(t = rb_ary_shift(GET_SZQUEUE_WAITERS(self)))) {
        rb_thread_wakeup_alive(t);
    }
    return vmax;
}
            
num_waiting() click to toggle source

Returns the number of threads waiting on the queue.

 
               static VALUE
rb_szqueue_num_waiting(VALUE self)
{
    long len = queue_num_waiting(self) + szqueue_num_waiting_producer(self);
    return ULONG2NUM(len);
}
            
pop(non_block=false) click to toggle source
deq(non_block=false)
shift(non_block=false)

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.

 
               static VALUE
rb_szqueue_pop(int argc, VALUE *argv, VALUE self)
{
    int should_block = queue_pop_should_block(argc, argv);
    return szqueue_do_pop(self, should_block);
}
            
Also aliased as: deq, shift
push(object, non_block=false) click to toggle source
enq(object, non_block=false)
<<(object)

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.

 
               static VALUE
rb_szqueue_push(int argc, VALUE *argv, VALUE self)
{
    struct waiting_delete args;
    int should_block = szqueue_push_should_block(argc, argv);
    args.waiting = GET_SZQUEUE_WAITERS(self);
    args.th      = rb_thread_current();

    while (queue_length(self) >= GET_SZQUEUE_ULONGMAX(self)) {
        if (!should_block) {
            rb_raise(rb_eThreadError, "queue full");
        }
        else if (queue_closed_p(self)) {
            goto closed;
        }
        else {
            rb_ary_push(args.waiting, args.th);
            rb_ensure(queue_sleep, Qfalse, queue_delete_from_waiting, (VALUE)&args);
        }
    }

    if (queue_closed_p(self)) {
      closed:
        raise_closed_queue_error(self);
    }

    return queue_do_push(self, argv[0]);
}
            
Also aliased as: enq, <<
shift(*args) click to toggle source
Alias for: pop