Question

The idea is that the input will be provided by the console, and will be identified with a unique ‘id’ as the first word of the input. A new thread is spawned when a new id is encountered, with the subsequent input being ‘start’. The thread should close when an input with the same id will say ‘close’. The ordering of the statements is random.

Answer 1

The trick here is to have a single thread (most easily the main thread) do all the reading. That thread will parse the command, start or stop threads, and dispatch commands to the threads. Each thread will have its own Queue from which it reads commands and into which the main thread puts the commands. Let’s see how it might be done.

We’ll start with a little module for the control commands, so that they’re DRY:

module ControlCommands
  START_COMMAND = 'start'
  STOP_COMMAND = 'stop'
end

Now let’s see the “main”:

class Main

  def initialize
    @workers = Workers.new
    @console = Console.new(@workers)
  end

  def run
    @console.read_and_dispatch
    @workers.join
  end

end

Main.new.run

There’s nothing much going on here. We make a console, and tell it to read commands and dispatch them to the workers. The console does not return from that until it has run out of input. The call to @workers.join make sure all the workers have finished working and properly shut down before the program exits.

Here’s the Console class:

class Console

  def initialize(workers)
    @workers = workers
  end

  def read_and_dispatch
    while input = gets
      @workers.dispatch *parse_input(input)
    end
  end

  private

  def parse_input(input)
    input.match(/^(\w+) *(.*)$/)[1..2]
  end

end

read_and_dispatch is the main loop. All that it is responsible for is reading and parsing input. As long as there is input, it splits it into the worker name and command, and then tells the workers to handle the command.

Here’s the Workers class:

class Workers

  include ControlCommands

  def initialize
    @workers = {}
  end

  def dispatch(worker_name, command)
    case command
    when START_COMMAND
      start_worker worker_name
    when STOP_COMMAND
      stop_worker worker_name
    else
      dispatch_worker worker_name, command
    end
  end

  def join
    @workers.each do |worker_name, worker|
      worker.stop
      worker.join
    end
  end

  private

  def start_worker(worker_name)
    @workers[worker_name] = Worker.new(worker_name)
  end

  def stop_worker(worker_name)
    @workers[worker_name].stop
  end

  def dispatch_worker(worker_name, command)
    @workers[worker_name].dispatch command
  end

end

This is where most of the meat is. This class creates workers (threads), stop them, and dispatches commands to them. Note that there is no error handling here: If you try to stop a thread that isn’t started, start one that’s already started, or dispatch a command to one that doesn’t exist, the program will crash or misbehave. I’ll leave the handling of those situations as an “exercise for the reader.”

Here’s the Worker class:

class Worker

  include ControlCommands

  def initialize(name)
    @name = name
    @commands = Queue.new
    @thread = start_thread
  end

  def dispatch(command)
    @commands.enq command
  end

  def stop
    @commands.enq STOP_COMMAND
  end

  def join
    @thread.join
  end

  private

  def start_thread
    Thread.new do
      loop do
        command = @commands.deq
        break if command == STOP_COMMAND
        process_command command
      end
    end
  end

  def process_command(command)
    print "thread #{@name} received command #{command.inspect}\n"
  end

end

This class contains the thread, and the queue used to communicate the between the main thread (the one reading the console) and the worker thread. That queue is also used to stop a thread, synchronously, by putting a STOP_COMMAND in the queue which the thread responds to by exiting. It is best, when you can afford to, to stop threads synchronously rather than asynchronously.

Here’s a simple input file:

foo start
bar start
foo input
bar input
foo stop
bar stop

And the output when the program is presented with that input:

thread bar received command "input"
thread foo received command "input"