Project

General

Profile

Download (8.62 KB)

Bug #7097 » thread_variables.patch

tenderlovemaking (Aaron Patterson), 10/26/2012 07:19 AM

View differences:

NEWS
* added Struct#to_h returning values with keys corresponding to the
instance variable names.
* Thread
* added method:
* added Thread#thread_variable_get for getting thread local variables
(these are different than Fiber local variables).
* added Thread#thread_variable_set for setting thread local variables.
* added Thread#thread_variables for getting a list of the thread local
variable keys.
* added Thread#thread_variable? for testing to see if a particular thread
variable has been set.
* Time
* change return value:
* Time#to_s returned encoding defaults to US-ASCII but automatically
test/ruby/test_thread.rb
end
end
def test_main_thread_variable_in_enumerator
assert_equal Thread.main, Thread.current
Thread.current.thread_variable_set :foo, "bar"
thread, value = Fiber.new {
Fiber.yield [Thread.current, Thread.current.thread_variable_get(:foo)]
}.resume
assert_equal Thread.current, thread
assert_equal Thread.current.thread_variable_get(:foo), value
end
def test_thread_variable_in_enumerator
Thread.new {
Thread.current.thread_variable_set :foo, "bar"
thread, value = Fiber.new {
Fiber.yield [Thread.current, Thread.current.thread_variable_get(:foo)]
}.resume
assert_equal Thread.current, thread
assert_equal Thread.current.thread_variable_get(:foo), value
}.join
end
def test_thread_variables
assert_equal [], Thread.new { Thread.current.thread_variables }.join.value
t = Thread.new {
Thread.current.thread_variable_set(:foo, "bar")
Thread.current.thread_variables
}
assert_equal [:foo], t.join.value
end
def test_thread_variable?
refute Thread.new { Thread.current.thread_variable?("foo") }.join.value
t = Thread.new {
Thread.current.thread_variable_set("foo", "bar")
}.join
assert t.thread_variable?("foo")
assert t.thread_variable?(:foo)
refute t.thread_variable?(:bar)
end
def test_thread_variable_strings_and_symbols_are_the_same_key
t = Thread.new {}.join
t.thread_variable_set("foo", "bar")
assert_equal "bar", t.thread_variable_get(:foo)
end
def test_thread_variable_frozen
t = Thread.new { }.join
t.freeze
assert_raises(RuntimeError) do
t.thread_variable_set(:foo, "bar")
end
end
def test_thread_variable_security
t = Thread.new { sleep }
assert_raises(SecurityError) do
Thread.new { $SAFE = 4; t.thread_variable_get(:foo) }.join
end
assert_raises(SecurityError) do
Thread.new { $SAFE = 4; t.thread_variable_set(:foo, :baz) }.join
end
end
def test_mutex_synchronize
m = Mutex.new
r = 0
thread.c
/*
* call-seq:
* thr.thread_variable_get(key) -> obj or nil
*
* Returns the value of a thread local variable that has been set. Note that
* these are different than fiber local values. For fiber local values,
* please see Thread#[] and Thread#[]=.
*
* Thread local values are carried along with threads, and do not respect
* fibers. For example:
*
* Thread.new {
* Thread.current.thread_variable_set("foo", "bar") # set a thread local
* Thread.current["foo"] = "bar" # set a fiber local
*
* Fiber.new {
* Fiber.yield [
* Thread.current.thread_variable_get("foo"), # get the thread local
* Thread.current["foo"], # get the fiber local
* ]
* }.resume
* }.join.value # => ['bar', nil]
*
* The value "bar" is returned for the thread local, where nil is returned
* for the fiber local. The fiber is executed in the same thread, so the
* thread local values are available.
*
* See also Thread#[]
*/
static VALUE
rb_thread_variable_get(VALUE thread, VALUE id)
{
VALUE locals;
rb_thread_t *th;
GetThreadPtr(thread, th);
if (rb_safe_level() >= 4 && th != GET_THREAD()) {
rb_raise(rb_eSecurityError, "Insecure: can't modify thread locals");
}
locals = rb_iv_get(thread, "locals");
return rb_hash_aref(locals, ID2SYM(rb_to_id(id)));
}
/*
* call-seq:
* thr.thread_variable_set(key, value)
*
* Sets a thread local with +key+ to +value+. Note that these are local to
* threads, and not to fibers. Please see Thread#thread_variable_get and
* Thread#[] for more information.
*/
static VALUE
rb_thread_variable_set(VALUE thread, VALUE id, VALUE val)
{
VALUE locals;
rb_thread_t *th;
GetThreadPtr(thread, th);
if (rb_safe_level() >= 4 && th != GET_THREAD()) {
rb_raise(rb_eSecurityError, "Insecure: can't modify thread locals");
}
if (OBJ_FROZEN(thread)) {
rb_error_frozen("thread locals");
}
locals = rb_iv_get(thread, "locals");
return rb_hash_aset(locals, ID2SYM(rb_to_id(id)), val);
}
/*
* call-seq:
* thr.key?(sym) -> true or false
*
* Returns <code>true</code> if the given string (or symbol) exists as a
......
return ary;
}
static int
keys_i(VALUE key, VALUE value, VALUE ary)
{
rb_ary_push(ary, key);
return ST_CONTINUE;
}
/*
* call-seq:
* thr.thread_variables -> array
*
* Returns an an array of the names of the thread-local variables (as Symbols).
*
* thr = Thread.new do
* Thread.current.thread_variable_set(:cat, 'meow')
* Thread.current.thread_variable_set("dog", 'woof')
* end
* thr.join #=> #<Thread:0x401b3f10 dead>
* thr.thread_variables #=> [:dog, :cat]
*
* Note that these are not fiber local variables. Please see Thread#[] and
* Thread#thread_variable_get for more details.
*/
static VALUE
rb_thread_variables(VALUE thread)
{
VALUE locals;
VALUE ary;
locals = rb_iv_get(thread, "locals");
ary = rb_ary_new();
rb_hash_foreach(locals, keys_i, ary);
return ary;
}
/*
* call-seq:
* thr.thread_variable?(key) -> true or false
*
* Returns <code>true</code> if the given string (or symbol) exists as a
* thread-local variable.
*
* me = Thread.current
* me.thread_variable_set(:oliver, "a")
* me.thread_variable?(:oliver) #=> true
* me.thread_variable?(:stanley) #=> false
*
* Note that these are not fiber local variables. Please see Thread#[] and
* Thread#thread_variable_get for more details.
*/
static VALUE
rb_thread_variable_p(VALUE thread, VALUE key)
{
VALUE locals;
locals = rb_iv_get(thread, "locals");
if (!RHASH(locals)->ntbl)
return Qfalse;
if (st_lookup(RHASH(locals)->ntbl, ID2SYM(rb_to_id(key)), 0)) {
return Qtrue;
}
return Qfalse;
}
/*
* call-seq:
* thr.priority -> integer
......
rb_define_method(rb_cThread, "priority", rb_thread_priority, 0);
rb_define_method(rb_cThread, "priority=", rb_thread_priority_set, 1);
rb_define_method(rb_cThread, "status", rb_thread_status, 0);
rb_define_method(rb_cThread, "thread_variable_get", rb_thread_variable_get, 1);
rb_define_method(rb_cThread, "thread_variable_set", rb_thread_variable_set, 2);
rb_define_method(rb_cThread, "thread_variables", rb_thread_variables, 0);
rb_define_method(rb_cThread, "thread_variable?", rb_thread_variable_p, 1);
rb_define_method(rb_cThread, "alive?", rb_thread_alive_p, 0);
rb_define_method(rb_cThread, "stop?", rb_thread_stop_p, 0);
rb_define_method(rb_cThread, "abort_on_exception", rb_thread_abort_exc, 0);
vm.c
GetThreadPtr(self, th);
th_init(th, self);
rb_iv_set(self, "locals", rb_hash_new());
th->vm = vm;
th->top_wrapper = 0;
......
/* create main thread */
th_self = th->self = TypedData_Wrap_Struct(rb_cThread, &thread_data_type, th);
rb_iv_set(th_self, "locals", rb_hash_new());
vm->main_thread = th;
vm->running_thread = th;
th->vm = vm;
(2-2/3)