ThreadGroup

class ThreadGroup

Parent:Object

ThreadGroup提供了将多个线程作为一个组跟踪的方法。

一个给定的Thread对象一次只能属于一个ThreadGroup；将线程添加到新组中会将其从以前的任何组中移除。

新创建的线程与创建它们的线程属于同一组。

常量

默认

Ruby启动时创建的默认ThreadGroup；所有线程都属于它默认情况下。

公共实例方法

add(thread) → thgrp Show source

将该给定添加thread到该组中，将其从其它可能以前曾经是其成员的组中删除。

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}"

这将产生：

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>

static VALUE
thgroup_add(VALUE group, VALUE thread)
{
    rb_thread_t *th;
    struct thgroup *data;

    GetThreadPtr(thread, th

    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 (!th->thgroup) {
        return Qnil;
    }

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

    th->thgroup = group;
    return group;
}

enclose → thgrp Show source

阻止将线程添加到接收的ThreadGroup或从接收的ThreadGroup中移除。

新线程仍然可以在封闭的ThreadGroup中启动。

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

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

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

    return group;
}

enclosed? → true or false Show source

如果thgrp封闭，则返回true。另见#enclose。

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

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

list → array Show source

返回属于此组的所有现有Thread对象的数组。

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

static VALUE
thgroup_list(VALUE group)
{
    VALUE ary = rb_ary_new(
    rb_vm_t *vm = GET_THREAD()->vm;
    rb_thread_t *th = 0;

    list_for_each(&vm->living_threads, th, vmlt_node) {
        if (th->thgroup == group) {
            rb_ary_push(ary, th->self
        }
    }
    return ary;
}