# class ThreadsWait

This class watches for termination of multiple threads. Basic functionality (wait until specified threads have terminated) can be accessed through the class method ::all_waits. Finer control can be gained using instance methods.

Example:

    ThreadsWait.all_waits(thr1, thr2, ...) do |t|
      STDERR.puts "Thread #{t} has terminated."
    end

    th = ThreadsWait.new(thread1,...)
    th.next_wait # next one to be done

### Attributes

threads[R]

Returns the array of threads that have not terminated yet.

### Public Class Methods

all_waits(*threads) { |thread| ... } click to toggle source

Waits until all specified threads have terminated. If a block is provided, it is executed for each thread as they terminate.

    # File lib/thwait.rb, line 35
    def ThreadsWait.all_waits(*threads) # :yield: thread
      tw = ThreadsWait.new(*threads)
      if block_given?
        tw.all_waits do |th|
          yield th
        end
      else
        tw.all_waits
      end
    end

new(*threads) click to toggle source

Creates a ThreadsWait object, specifying the threads to wait on. Non-blocking.

    # File lib/thwait.rb, line 50
    def initialize(*threads)
      @threads = []
      @wait_queue = Thread::Queue.new
      join_nowait(*threads) unless threads.empty?
    end

### Public Instance Methods

all_waits() { |th| ... } click to toggle source

Waits until all of the specified threads are terminated. If a block is supplied for the method, it is executed for each thread termination.

Raises exceptions in the same manner as `next_wait`.

    # File lib/thwait.rb, line 123
    def all_waits
      until @threads.empty?
        th = next_wait
        yield th if block_given?
      end
    end

empty?() click to toggle source

Returns `true` if there are no threads in the pool still running.

    # File lib/thwait.rb, line 62
    def empty?
      @threads.empty?
    end

finished?() click to toggle source

Returns `true` if any thread has terminated and is ready to be collected.

    # File lib/thwait.rb, line 69
    def finished?
      !@wait_queue.empty?
    end

join(*threads) click to toggle source

Waits for specified threads to terminate, and returns when one of the threads terminated.

    # File lib/thwait.rb, line 77
    def join(*threads)
      join_nowait(*threads)
      next_wait
    end

join_nowait(*threads) click to toggle source

Specifies the threads that this object will wait for, but does not actually wait.

    # File lib/thwait.rb, line 86
    def join_nowait(*threads)
      threads.flatten!
      @threads.concat threads
      for th in threads
        Thread.start(th) do |t|
          begin
            t.join
          ensure
            @wait_queue.push t
          end
        end
      end
    end

next_wait(nonblock = nil) click to toggle source

Waits until any of the specified threads has terminated, and returns the one that does.

If there is no thread to wait, raises `ErrNoWaitingThread`. If `nonblock` is true, and there is no terminated thread, raises `ErrNoFinishedThread`.

    # File lib/thwait.rb, line 107
    def next_wait(nonblock = nil)
      ThreadsWait.fail ErrNoWaitingThread if @threads.empty?
      begin
        @threads.delete(th = @wait_queue.pop(nonblock))
        th
      rescue ThreadError
        ThreadsWait.fail ErrNoFinishedThread
      end
    end