class ThreadGroup

ThreadGroup bietet eine Möglichkeit, eine Anzahl von Threads als Gruppe zu verfolgen.

Ein gegebener Thread-Objekt kann jederzeit nur zu einer ThreadGroup gehören; das Hinzufügen eines Threads zu einer neuen Gruppe entfernt ihn aus jeder vorherigen Gruppe.

Neu erstellte Threads gehören zur selben Gruppe wie der Thread, von dem sie erstellt wurden.

Constants

Standard: Die Standard-ThreadGroup, die beim Start von Ruby erstellt wird; alle Threads gehören standardmäßig dazu.

Öffentliche Instanzmethoden

add(thread) → thgrp

Source

static VALUE
thgroup_add(VALUE group, VALUE thread)
{
    rb_thread_t *target_th = rb_thread_ptr(thread);
    struct thgroup *data;

    if (OBJ_FROZEN(group)) {
        rb_raise(rb_eThreadError, "can't move to the frozen thread group");
    }
    TypedData_Get_Struct(group, struct thgroup, &thgroup_data_type, data);
    if (data->enclosed) {
        rb_raise(rb_eThreadError, "can't move to the enclosed thread group");
    }

    if (OBJ_FROZEN(target_th->thgroup)) {
        rb_raise(rb_eThreadError, "can't move from the frozen thread group");
    }
    TypedData_Get_Struct(target_th->thgroup, struct thgroup, &thgroup_data_type, data);
    if (data->enclosed) {
        rb_raise(rb_eThreadError,
                 "can't move from the enclosed thread group");
    }

    target_th->thgroup = group;
    return group;
}

Fügt den gegebenen thread dieser Gruppe hinzu und entfernt ihn aus jeder anderen Gruppe, der er möglicherweise zuvor angehört hat.

puts "Initial group is #{ThreadGroup::Default.list}"
tg = ThreadGroup.new
t1 = Thread.new { sleep }
t2 = Thread.new { sleep }
puts "t1 is #{t1}"
puts "t2 is #{t2}"
tg.add(t1)
puts "Initial group now #{ThreadGroup::Default.list}"
puts "tg group now #{tg.list}"

Dies wird folgendes ergeben

Initial group is #<Thread:0x401bdf4c>
t1 is #<Thread:0x401b3c90>
t2 is #<Thread:0x401b3c18>
Initial group now #<Thread:0x401b3c18>#<Thread:0x401bdf4c>
tg group now #<Thread:0x401b3c90>

enclose → thgrp

Source

static VALUE
thgroup_enclose(VALUE group)
{
    struct thgroup *data;

    TypedData_Get_Struct(group, struct thgroup, &thgroup_data_type, data);
    data->enclosed = 1;

    return group;
}

Verhindert, dass Threads zur empfangenden ThreadGroup hinzugefügt oder aus ihr entfernt werden.

Neue Threads können in einer geschlossenen ThreadGroup weiterhin gestartet werden.

ThreadGroup::Default.enclose        #=> #<ThreadGroup:0x4029d914>
thr = Thread.new { Thread.stop }    #=> #<Thread:0x402a7210 sleep>
tg = ThreadGroup.new                #=> #<ThreadGroup:0x402752d4>
tg.add thr
#=> ThreadError: can't move from the enclosed thread group

enclosed? → true oder false

Source

static VALUE
thgroup_enclosed_p(VALUE group)
{
    struct thgroup *data;

    TypedData_Get_Struct(group, struct thgroup, &thgroup_data_type, data);
    return RBOOL(data->enclosed);
}

Gibt true zurück, wenn die thgrp geschlossen ist. Siehe auch ThreadGroup#enclose.

list → array

Source

static VALUE
thgroup_list(VALUE group)
{
    VALUE ary = rb_ary_new();
    rb_thread_t *th = 0;
    rb_ractor_t *r = GET_RACTOR();

    ccan_list_for_each(&r->threads.set, th, lt_node) {
        if (th->thgroup == group) {
            rb_ary_push(ary, th->self);
        }
    }
    return ary;
}

Gibt ein Array aller vorhandenen Thread-Objekte zurück, die zu dieser Gruppe gehören.

ThreadGroup::Default.list   #=> [#<Thread:0x401bdf4c run>]