Question

I have a rabbitmq queue subscriber that spins up a new thread every time a new message is consumed:

AMQP.start(@conf) do |connection|
  channel = AMQP::Channel.new(connection)

  requests_queue = channel.queue("one")

  requests_queue.subscribe(:ack => true) do |header, body|
    puts "we have a message at #{Time.now} and n is #{n}"

    url_search = MultiJson.decode(body)

    Thread.new do
      5.times do
        lead = get_lead(n, (n == 5))

        puts "message #{n} is_last = #{lead.is_last} at #{Time.now}";

        AMQP::Exchange.default.publish(
                                        MultiJson.encode(lead), 
                                        :routing_key => header.reply_to,
                                        :correlation_id => header.correlation_id
                                      )

        n += 1
        sleep(2)
      end
    end
  end
end

My question is, how do I dispose of the thread after the message is handled? Should I be using the threadpool?

I am using JRuby. Does the above code create a Java JVM thread behind the scenes using the normal ruby syntax or should I be explicitly creating a Java thread?

Answer 1

You don’t have to manually dispose the thread I think, and you should be using ruby threads, from what I gather they are java threads in jruby, which is from what jruby gets it’s nice performance.

A common thing to do is to spin up a couple of threads and then join all of them before continuing if you want to be sure that all are complete before the next step, but it doesn’t seem to be required here.

Here’s a little test program:

# foo.rb
a = Thread.new { print "a"; sleep(1); print "b"; print "c" }
require 'pp'
pp Thread.list
puts "foo"
sleep(2); 
pp Thread.list
puts "bar"

As you can see the spawned background thread is automatically removed. (Tested in jruby as well as 1.9.2

$ ruby foo.rb 
a[#<Thread:0x00000100887678 run>, #<Thread:0x0000010086c7d8 sleep>]
foo
bc[#<Thread:0x00000100887678 run>]
bar