Module: Extlib::Pooling

### Home Classes Methods

### In Files

- lib/extlib/pooling.rb

### Namespace

- CLASS Extlib::Pooling::InvalidResourceError
- CLASS Extlib::Pooling::Pool

### Methods

- ::__new
- ::__pool_lock
- ::__pool_wait
- ::__pools
- ::append_pool
- ::included
- ::lock
- ::new
- ::pool_size
- ::pools
- ::scavenger
- ::scavenger?
- ::scavenger_interval
- #detach
- #release

### Files

- LICENSE
- README.rdoc

### Class/Module Index

Quicksearch

- Extlib
- Extlib::Assertions
- Extlib::ByteArray
- Extlib::Hook
- Extlib::Hook::ClassMethods
- Extlib::Inflection
- Extlib::LocalObjectSpace
- Extlib::Logger
- Extlib::Pooling
- Extlib::Pooling::InvalidResourceError
- Extlib::Pooling::Pool
- Extlib::SimpleSet
- Gem
- Gem::SourceIndex
- Gem::Specification
- LazyModule
- LazyModule::ClassMethods
- Array
- Class
- DateTime
- Dictionary
- FalseClass
- Hash
- LazyArray
- Mash
- Module
- NilClass
- Numeric
- Object
- ObjectSpace
- Pathname
- REXMLUtilityNode
- String
- Struct
- Symbol
- Time
- ToHashParser
- TrueClass
- VirtualFile

No matching classes.

# Extlib::Pooling

#### Notes

Provides pooling support to class it got included in.

Pooling of objects is a faster way of aquiring instances of objects compared to regular allocation and initialization because instances are keeped 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 poolable 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.

### Public Class Methods

__new(*args) click to toggle source
Alias for: new
__pool_lock() click to toggle source

    # File lib/extlib/pooling.rb, line 95
    def self.__pool_lock
      @__pool_lock
    end

__pool_wait() click to toggle source

    # File lib/extlib/pooling.rb, line 99
    def self.__pool_wait
      @__pool_wait
    end

__pools() click to toggle source

    # File lib/extlib/pooling.rb, line 107
    def self.__pools
      @__pools
    end

append_pool(pool) click to toggle source

    # File lib/extlib/pooling.rb, line 71
    def self.append_pool(pool)
      lock.synchronize do
        pools << pool
      end
      Extlib::Pooling.scavenger
    end

included(target) click to toggle source

    # File lib/extlib/pooling.rb, line 85
    def self.included(target)
      target.class_eval do
        class << self
          alias __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(self.pool_size, self, args) }).new
        end

        def self.__pools
          @__pools
        end

        def self.pool_size
          8
        end
      end
    end

lock() click to toggle source

    # File lib/extlib/pooling.rb, line 78
    def self.lock
      @lock ||= Mutex.new
    end

new(*args) click to toggle source

    # File lib/extlib/pooling.rb, line 103
    def self.new(*args)
      (@__pools[args] ||= __pool_lock.synchronize { Pool.new(self.pool_size, self, args) }).new
    end

Also aliased as: __new
pool_size() click to toggle source

    # File lib/extlib/pooling.rb, line 111
    def self.pool_size
      8
    end

pools() click to toggle source

    # File lib/extlib/pooling.rb, line 67
    def self.pools
      @pools ||= Set.new
    end

scavenger() click to toggle source

    # File lib/extlib/pooling.rb, line 32
    def self.scavenger
      unless scavenger?
        @scavenger = Thread.new do
          running = true
          while running do
            # 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
                  if pool.expired?
                    pool.dispose
                  end
                end
                # end
              end

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

      @scavenger.priority = -10
      @scavenger
    end

scavenger?() click to toggle source

    # File lib/extlib/pooling.rb, line 28
    def self.scavenger?
      defined?(@scavenger) && !@scavenger.nil? && @scavenger.alive?
    end

scavenger_interval() click to toggle source

    # File lib/extlib/pooling.rb, line 231
    def self.scavenger_interval
      60
    end

### Public Instance Methods

detach() click to toggle source

    # File lib/extlib/pooling.rb, line 121
    def detach
      @__pool.delete(self) unless @__pool.nil?
    end

release() click to toggle source

    # File lib/extlib/pooling.rb, line 117
    def release
      @__pool.release(self) unless @__pool.nil?
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.