>_<.

1

require 'thread'
require 'timeout'

class ObjectPoolError < StandardError; end
class ObjectPoolFull < ObjectPoolError; end
class ObjectPoolTimeOut < ObjectPoolFull; end

class ObjectPoolConfig
    attr_accessor :pool_size, :timeout
    
    def initialize(pool_size, timeout)
        @pool_size = pool_size
        @timeout = timeout
    end
    
    def initialize(params)
        @pool_size = params[:pool_size]
        @timeout = params[:timeout]
    end
end

class ObjectPoolCreator
    def create
        raise ObjectPoolError, "override this method"
    end
    
    def valid?(object)
        true
    end
    
    def expire
    end
end

class ObjectPool
    def initialize(object_creator, config = nil)
        @object_creator = object_creator
        raise ObjectPoolError, "First Parameter should be a kind of ObjectPoolCreator" if !@object_creator.kind_of?(ObjectPoolCreator)
        
        @config = config
        self_configuration if @config.nil?
        raise ObjectPoolError, "Second Parameter should be a kind of ObjectPoolConfig" if !@config.kind_of?(ObjectPoolConfig)
        
        @mutex = Mutex.new
        @cond = ConditionVariable.new
        @activations = {}
        @idles = []
    end
    
    def borrow_object
        @mutex.synchronize do
            result = nil
            
            if @activations.size + @idles.size >= @config.pool_size
                raise ObjectPoolFull, "%s is full" % self.class if @config.timeout == 0
                
                begin
                    timeout(@config.timeout) { @cond.wait(@mutex) }
                rescue TimeoutError
                    raise ObjectPoolTimeOut, "%s borrow_object is timeout" % self.class
                end
                
                result = @idles.pop
            elsif !@idles.empty?
                result = @idles.pop
            else
                result = create_object
            end
            
            if !@object_creator.valid?(result)
                result.expire
                result = create_object
            end
            
            @activations.store result.__id__, result   
            return result
        end
    end
    
    def return_object(object)
        @mutex.synchronize do 
            @activations.delete object.__id__
            @idles << object
            @cond.signal
        end
    end
    
    private
    def self_configuration
        @config = ObjectPoolConfig.new(10, 1)
    end

    def create_object
        @object_creator.create
    end
end

require "ObjectPool"
require "thread"

class VeryBigObject
    attr_reader :a
    
    def initialize
        @a = rand
    end
end

class BigObjectCreator < ObjectPoolCreator
    def create
        VeryBigObject.new
    end
end

class BigObjectPool < ObjectPool
    def initialize(creator, config)
        super creator, config
    end
end

pool = BigObjectPool.new  BigObjectCreator.new, 
                          ObjectPoolConfig.new(:pool_size => 9, :timeout => 5)

objects = []

9.times do
    a = pool.borrow_object
    puts a.a
    objects << a
end

th1 = Thread.new {
    a = pool.borrow_object
    puts a.a
}

th2 = Thread.new {
    sleep 2
    5.times do 
        pool.return_object objects.pop    
    end
}

th2.join
th1.join

0.906020404796193
0.553387475480747
0.56834728105222
0.816481270695782
0.230136922252277
0.402905837293753
0.490467546431542
0.429482327781051
0.963596488667419   <-- pending
0.963596488667419