Module: DataObjects::Pooling

Defined in:
lib/data_objects/pooling.rb

Overview

Notes

Provides pooling support to class it got included in.

Pooling of objects is a faster way of acquiring instances of objects compared to regular allocation and initialization because instances are kept in memory reused.

Classes that include Pooling module have re-defined new method that returns instances acquired from pool.

Term resource is used for any type of pool-able objects and should NOT be thought as DataMapper Resource or ActiveResource resource and such.

In Data Objects connections are pooled so that it is unnecessary to allocate and initialize connection object each time connection is needed, like per request in a web application.

Pool obviously has to be thread safe because state of object is reset when it is released.

Defined Under Namespace

Classes: InvalidResourceError, Pool

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.append_pool(pool) ⇒ Object 



74
75
76
77
78
79
 
# File 'lib/data_objects/pooling.rb', line 74

def self.append_pool(pool)
  lock.synchronize do
    pools << pool
  end
  DataObjects::Pooling.scavenger
end

.included(target) ⇒ Object 



88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/data_objects/pooling.rb', line 88

def self.included(target)
  lock.synchronize do
    unless target.respond_to? :__pools
      target.class_eval do
        class << self
          alias_method :__new, :new
        end

        @__pools     = {}
        @__pool_lock = Mutex.new
        @__pool_wait = ConditionVariable.new

        def self.__pool_lock
          @__pool_lock
        end

        def self.__pool_wait
          @__pool_wait
        end

        def self.new(*args)
          (@__pools[args] ||= __pool_lock.synchronize { Pool.new(pool_size, self, args) }).new
        end

        def self.__pools
          @__pools
        end

        def self.pool_size
          8
        end
      end
    end
  end
end

.lock ⇒ Object 



81
82
83
 
# File 'lib/data_objects/pooling.rb', line 81

def self.lock
  @lock ||= Mutex.new
end

.pools ⇒ Object 



70
71
72
 
# File 'lib/data_objects/pooling.rb', line 70

def self.pools
  @pools ||= Set.new
end

.scavenger ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/data_objects/pooling.rb', line 39

def self.scavenger
  unless scavenger?
    @scavenger = Thread.new do
      running = true
      while running
        # Sleep before we actually start doing anything.
        # Otherwise we might clean up something we just made
        sleep(scavenger_interval)

        lock.synchronize do
          pools.each do |pool|
            # This is a useful check, but non-essential, and right now it breaks lots of stuff.
            # if pool.expired?
            pool.lock.synchronize do
              pool.dispose if pool.expired?
            end
            # end
          end

          # The pool is empty, we stop the scavenger
          # It wil be restarted if new resources are added again
          running = false if pools.empty?
        end
      end
    end
  end

  @scavenger.priority = -10
  @scavenger
end

.scavenger? ⇒ Boolean

Returns:

  • (Boolean) 


35
36
37
 
# File 'lib/data_objects/pooling.rb', line 35

def self.scavenger?
  defined?(@scavenger) && !@scavenger.nil? && @scavenger.alive?
end

.scavenger_interval ⇒ Object 



239
240
241
 
# File 'lib/data_objects/pooling.rb', line 239

def self.scavenger_interval
  60
end

Instance Method Details

#detach ⇒ Object 



128
129
130
 
# File 'lib/data_objects/pooling.rb', line 128

def detach
  @__pool&.delete(self)
end

#release ⇒ Object 



124
125
126
 
# File 'lib/data_objects/pooling.rb', line 124

def release
  @__pool&.release(self)
end