#require "rubygems"
#require "fastthread"
require "thread"

class WorkData
  attr_accessor :data,:job_method,:job_key
  def initialize(args,job_method)
    @data = args
    # @job_key = job_key
    @job_method = job_method
  end
end

class ThreadPool
  attr_accessor :size,:threads,:work_queue
  attr_accessor :master
  def initialize(master,size)
    @master = master
    @size = size
    @work_queue = Queue.new
    puts Time.now
    for x in 0..@size
      add_thread
    end
    puts "all threads started: #{Time.now}"
  end
  def defer(args,job_method)
    #job_key = Thread.current[:job_key]
    @work_queue << WorkData.new(args,job_method)
  end

  def add_thread
    Thread.new do
      Thread.current[:job_key] = nil
      while true
        task = @work_queue.pop
        #Thread.current[:job_key] = task.job_key
        block_result = run_task(task)
      end
    end
  end

  def run_task task
    begin
      t_data = task.data
      @master.send(task.job_method,t_data)
    rescue
      return nil
    end
  end
end

class SomeLoop
  attr_accessor :thread_pool
  def initialize
    @thread_pool = ThreadPool.new(self,1000)
  end

  def start
    count = 0
    counter = 0
    Signal.trap("USR1") { request_generator }
    loop do
      if count < 600
        make_requests()
        sleep(0.005)
        count += 1
      end
      sleep(0.005)
      if (counter%100 == 0 && length != 0)
        puts "Queue Length: #{length}"
        puts "Count : #{count}"
      elsif(length == 0 && count >= 600)
        puts "All tasks has been executed"
      end
      counter += 1
    end
  end


  def request_generator
    puts "lets make request"
    GC.start
    600.times {
      make_requests()
      sleep(0.005)
    }
  end

  def length
    thread_pool.work_queue.length
  end

  def do_work count
    sleep(0.5)
  end

  def make_requests
    100.times { |i|
      arg = "L" * (i*100)
      thread_pool.defer(arg,:do_work)
    }
  end
end

Thread.abort_on_exception = true
a = SomeLoop.new
a.start