Class: ThreadGroup

Inherits:
Object show all
Defined in:
thread.c,
thread.c

Overview

ThreadGroup provides a means of keeping track of a number of threads as a

group.

A given Thread object can only belong to one ThreadGroup at a time; adding
a thread to a new group will remove it from any previous group.

Newly created threads belong to the same group as the thread from which they
were created.

Constant Summary collapse

Default =

The default ThreadGroup created when Ruby starts; all Threads belong to it

by default.
th->thgroup

Instance Method Summary collapse

Instance Method Details

#add(thread) ⇒ Object

Adds the given thread to this group, removing it from any other group to which it may have previously been a member.

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

This will produce:

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>

4965
4966
4967
4968
4969
4970
4971
4972
4973
4974
4975
4976
4977
4978
4979
4980
4981
4982
4983
4984
4985
4986
4987
4988
4989
4990
4991
4992
4993
4994
# File 'thread.c', line 4965

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

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

#encloseObject

Prevents threads from being added to or removed from the receiving ThreadGroup.

New threads can still be started in an enclosed 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

4908
4909
4910
4911
4912
4913
4914
4915
4916
4917
# File 'thread.c', line 4908

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?Boolean

Returns true if the thgrp is enclosed. See also ThreadGroup#enclose.

Returns:

  • (Boolean)

4927
4928
4929
4930
4931
4932
4933
4934
4935
4936
# File 'thread.c', line 4927

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

#listArray

Returns an array of all existing Thread objects that belong to this group.

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

Returns:


4876
4877
4878
4879
4880
4881
4882
4883
4884
4885
4886
4887
4888
4889
# File 'thread.c', line 4876

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

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