Let's stop polluting the Thread.current hash

When writing libraries we often need “global”ish variables. In Ruby what most people use are class variables along with accessor methods to modify them. For example MyLibrary.my_variable. This is basically just namespacing a global:

class SomeLibrary
  def self.some_setting=(val)
    @@some_setting = val
  end

  def self.some_setting
    @@some_setting ||= :default
  end
end

When writing a thread-safe library sometimes we need variables which are specific to the thread that’s running. Quite often we just end up using Thread.current[:my_variable] and wrapping it with accessors:

class ThreadedLibrary
  def self.some_setting= val
    Thread.current[:some_setting] = val
  end

  def self.some_setting
    Thread.current[:some_setting] ||= :default
  end
end

The problem is that this is the equivalent of using $my_variable, just in a threaded context. Some other library might come along and decide to use Thread.current[:my_variable] too, and now you’re screwed.

I just noticed that the code for Time.zone in the latest version of Rails does this too, by using Thread.current[:time_zone]. I’m definitely not criticizing anyone though, because I did the exact same thing in my last post, lol. I’m just saying I think the use is somewhat prevalent.

Anyway, one solution is to use a class variable hash, which is keyed by the current thread. This is actually how ActiveRecord handles its per thread connections. Something like this:

class BetterThreadedLibrary
  @@some_setting = Hash.new {|h,k| h[k] = :default }
  def self.some_setting=(val)
    @@some_setting[Thread.current.object_id] = val
  end
  def self.some_setting
    @@some_setting[Thread.current.object_id]
  end
end

Since I think cattr_accessor from ActiveSupport is pretty great I thought it would be nice to have a threaded version of it. So here’s thread_local_accessor:

Update: Dan Kubb pointed out the original solution had a memory leak. As threads die and get GCed their key/values in the hash are never cleaned up. I have modified the solution to use a finalizer to take care of this.

class Class
  def thread_local_accessor name, options = {}
    m = Module.new
    m.module_eval do
      class_variable_set :"@@#{name}", Hash.new {|h,k| h[k] = options[:default] }
    end
    m.module_eval %{
      FINALIZER = lambda {|id| @@#{name}.delete id }

      def #{name}
        @@#{name}[Thread.current.object_id]
      end

      def #{name}=(val)
        ObjectSpace.define_finalizer Thread.current, FINALIZER  unless @@#{name}.has_key? Thread.current.object_id
        @@#{name}[Thread.current.object_id] = val
      end
    }

    class_eval do
      include m
      extend m
    end
  end
end

Here’s how it works:

require 'test/unit'

class ThreadedLib
  thread_local_accessor :some_setting, :default => :default
end

class TestThreadedClassAttrAccessor < Test::Unit::TestCase
  def test_that_it_works!
    instance = ThreadedLib.new

    ThreadedLib.some_setting = 5

    assert_equal 5, ThreadedLib.some_setting
    assert_equal 5, instance.some_setting

    Thread.new {
      instance.some_setting = 10

      assert_equal 10, ThreadedLib.some_setting
      assert_equal 10, instance.some_setting
    }.join

    Thread.new { assert_equal :default, ThreadedLib.some_setting }.join

    assert_equal 5, ThreadedLib.some_setting
  end
end

All suggestions and criticism welcome!