Terminating a Thread

Problem

You want to kill a thread before the end of the program.

Solution

A thread terminates if it reaches the end of its code block. The best way to terminate a thread early is to convince it to reach the end of its code block. This way, the thread can run cleanup code before dying.

This thread runs a loop while the instance variable continue is true. Set this variable to false, and the thread will die a natural death:

require hread class CounterThread < Thread def initialize @count = 0 @continue = true super do @count += 1 while @continue puts "I counted up to #{@count} before I was cruelly stopped." end end def stop @continue = false end end counter = CounterThread.new sleep 2 counter.stop # I counted up to 3413544 before I was cruelly stopped.

If you need to stop a thread that doesn offer a stop-like function, or you need to stop an out-of-control thread immediately, you can always call Thread#terminate. This method stops a thread in its tracks:

t = Thread.new { loop { puts I am the unstoppable thread! } } # I am the unstoppable thread! # I am the unstoppable thread! # I am the unstoppable thread! # I am the unstoppable thread! t.terminate

Discussion

Its better to convince someone they should do something than to force them to do it. The same is true of threads. Calling Thread.terminate is a bit like throwing an exception: it interrupts the normal flow of execution in an unpredictable place. Worse, theres no equivalent of a begin/ensure construct for thread termination, so calling THRead.terminate may corrupt your data or leave your program in an inconsistent state. If you plan to stop a thread before the program is over, you should build that capability into the thread object itself.

A common type of thread implements a loop: threads that process requests from a queue, or that periodically poll for new data. In these, the end of an iteration forms a natural stopping point. These threads can benefit from some simple VCR-style controls: pause, unpause, and stop.

Heres a Thread subclass which implements a loop that can be paused or stopped in a predictable way. A code block passed into the Thread constructor would implement the entire loop, but the code block passed into the LoopingThread constructor should implement only one iteration of the loop. Setup and cleanup code should be handled in the methods before_loop and after_loop.

class LoopingThread < Thread def initialize @stopped = false @paused = false super do before_loop until @stopped yield Thread.stop if @paused end after_loop end end def before_loop; end def after_loop; end def stop @stopped = true end def paused=(paused) @paused = paused run if !paused end end

Heres the CounterThread class from the Solution, implemented as a LoopingThread. Ive added a reader method for count so we can peek at its value when the thread is paused:

class PausableCounter < LoopingThread attr_reader :count def before_loop @count = 0 end def initialize super { @count += 1 } end def after_loop puts "I counted up to #{@count} before I was cruelly stopped." end end counter = PausableCounter.new sleep 2 counter.paused = true counter.count # => 819438 sleep 2 counter.count # => 819438 counter.paused = false sleep 2 counter.stop # I counted up to 1644324 before I was cruelly stopped. counter.count # => 1644324