# ThreadsWait (Class)

In: | thwait.rb
Parent: | Object

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

Example:

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

## Methods

all_waits all_waits empty? finished? join join_nowait new next_wait

## Constants

RCS_ID | = |

## Attributes

threads | [R] | Returns the array of threads in the wait queue.

## Public Class methods

all_waits(*threads) {|thread| ...}

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

[Source]

    # File thwait.rb, line 65
      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)

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

[Source]

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

## Public Instance methods

empty?()

Returns `true` if there are no threads to be synchronized.

[Source]

    # File thwait.rb, line 92
      def empty?
        @threads.empty?
      end

finished?()

Returns `true` if any thread has terminated.

[Source]

    # File thwait.rb, line 99
      def finished?
        !@wait_queue.empty?
      end

join(*threads)

Waits for specified threads to terminate.

[Source]

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

join_nowait(*threads)

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

[Source]

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

next_wait(nonblock = nil)

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`.

[Source]

    # File thwait.rb, line 133
      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

all_waits() {|th if block_given?| ...}

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`.

[Source]

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

[Validate]