Class: ThreadsWait (Ruby 2.3.2)
Description: Class : ThreadsWait - Ruby 2.3.2

- Home
- Core 2.3.2
- Std-lib 2.3.2
- Downloads

Support for the Ruby 2.3 series has ended. See here for reference.

### Home Classes Methods

### In Files

- thwait.rb

### Parent

Object

### Methods

- ::all_waits
- ::new
- #all_waits
- #empty?
- #finished?
- #join
- #join_nowait
- #next_wait

### Class/Module Index

Quicksearch

- Object
- ThWait
- ThreadsWait

No matching classes.

# 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) 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 thwait.rb, line 36
    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 thwait.rb, line 51
    def initialize(*threads)
      @threads = []
      @wait_queue = Queue.new
      join_nowait(*threads) unless threads.empty?
    end

### Public Instance Methods

all_waits() 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 thwait.rb, line 124
    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 thwait.rb, line 63
    def empty?
      @threads.empty?
    end

finished?() click to toggle source

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

                   # File thwait.rb, line 70
    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 thwait.rb, line 78
    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 thwait.rb, line 87
    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 thwait.rb, line 108
    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