123456789_123456789_123456789_123456789_123456789_

Class: Concurrent::MutexCountDownLatch

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, Synchronization::LockableObject
Instance Chain:
self, Synchronization::LockableObject
Inherits: Concurrent::Synchronization::LockableObject
Defined in: lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb

Overview

Note:

**Private Implementation:** This abstraction is a private, internal implementation detail. It should never be used directly.

A synchronization object that allows one thread to wait on multiple other threads. The thread that will wait creates a CountDownLatch and sets the initial value (normally equal to the number of other threads). The initiating thread passes the latch to the other threads then waits for the other threads by calling the #wait method. Each of the other threads calls #count_down when done with its work. When the latch counter reaches zero the waiting thread is unblocked and continues with its work. A CountDownLatch can be used only once. Its value cannot be reset.

Class Method Summary

Instance Method Summary

Synchronization::LockableObject - Inherited

#new_condition

Constructor Details

.new(count = 1) ⇒ MutexCountDownLatch

Create a new CountDownLatch with the initial #count.

Parameters:

  • count (new) (defaults to: 1) —

    the initial count

Raises:

  • (ArgumentError) —

    if #count is not an integer or is less than zero

[ GitHub ] 

  


# File 'lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb', line 12



def initialize(count = 1)
  Utility::NativeInteger.ensure_integer_and_bounds count
  Utility::NativeInteger.ensure_positive count

  super()
  synchronize { ns_initialize count }
end


  







Instance Method Details



  

    #count  ⇒ Fixnum 
  



  

    

The current value of the counter.


  





  
Returns:


    
  
  • 
    (Fixnum)
—    
    

    the current value of the counter
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb', line 34



def count
  synchronize { @count }
end


  








  

    #count_down  
  



  

    

Signal the latch to decrement the counter. Will signal all blocked threads when the #count reaches zero.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb', line 26



def count_down
  synchronize do
    @count -= 1 if @count > 0
    ns_broadcast if @count == 0
  end
end


  








  

    #wait(timeout = nil)  ⇒ Boolean 
  



  

    

Block on the latch until the counter reaches zero or until timeout is reached.


  





  
Parameters:


    
  
  • 
    timeout
    (Fixnum)
    (defaults to: nil)
—    
    

    the number of seconds to wait for the counter or nil to block indefinitely
    

    
  
    • 



Returns:


    
  
  • 
    (Boolean)
—    
    

    true if the #count reaches zero else false on timeout
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb', line 21



def wait(timeout = nil)
  synchronize { ns_wait_until(timeout) { @count == 0 } }
end