123456789_123456789_123456789_123456789_123456789_

Class: Concurrent::Tuple

Relationships & Source Files
Extension / Inclusion / Inheritance Descendants
Subclasses:
Concurrent::ThreadSafe::Util::PowerOfTwoTuple
Super Chains via Extension / Inclusion / Inheritance
Instance Chain:
self, Enumerable
Inherits: Object
Defined in: lib/concurrent-ruby/concurrent/tuple.rb

Overview

A fixed size array with volatile (synchronized, thread safe) getters/setters. Mixes in Ruby’s Enumerable module for enhanced search, sort, and traversal.

Examples:

tuple = Concurrent::Tuple.new(16)

tuple.set(0, :foo)                   #=> :foo  | volatile write
tuple.get(0)                         #=> :foo  | volatile read
tuple.compare_and_set(0, :foo, :bar) #=> true  | strong CAS
tuple.cas(0, :foo, :baz)             #=> false | strong CAS
tuple.get(0)                         #=> :bar  | volatile read

See Also:

Class Method Summary

Instance Attribute Summary

  • #size readonly

    The (fixed) size of the tuple.

Instance Method Summary

Constructor Details

.new(size) ⇒ Tuple

Create a new tuple of the given size.

Parameters:

  • size (Integer) —

    the number of elements in the tuple

[ GitHub ] 

  


# File 'lib/concurrent-ruby/concurrent/tuple.rb', line 29



def initialize(size)
  @size = size
  @tuple = tuple = ::Array.new(size)
  i = 0
  while i < size
    tuple[i] = Concurrent::AtomicReference.new
    i += 1
  end
end


  







Instance Attribute Details



  

    #size   (readonly)
  



  

    

The (fixed) size of the tuple.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/tuple.rb', line 24



attr_reader :size


  







Instance Method Details



  

    #cas(i, old_value, new_value)  
  



  

    

Alias for #compare_and_set.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/tuple.rb', line 73



alias_method :cas, :compare_and_set


  








  

    #compare_and_set(i, old_value, new_value)  ⇒ Boolean 
    Also known as: #cas
  



  

    

Set the value at the given index to the new value if and only if the current value matches the given old value.


  





  
Parameters:


    
  
  • 
    i
    (Integer)
—    
    

    the index for the element to set
    

    
  
    • 
  
  • 
    old_value
    (Object)
—    
    

    the value to compare against the current value
    

    
  
    • 
  
  • 
    new_value
    (Object)
—    
    

    the value to set at the given index
    

    
  
    • 



Returns:


    
  
  • 
    (Boolean)
—    
    

    true if the value at the given element was set else false
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/tuple.rb', line 69



def compare_and_set(i, old_value, new_value)
  return false if i >= @size || i < 0
  @tuple[i].compare_and_set(old_value, new_value)
end


  








  

    #each {|ref| ... } 
  



  

    

Calls the given block once for each element in self, passing that element as a parameter.


  





  
Yield Parameters:





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/tuple.rb', line 78



def each
  @tuple.each {|ref| yield ref.get}
end


  








  

    #get(i)  ⇒ Object 
    Also known as: #volatile_get
  



  

    

Get the value of the element at the given index.


  





  
Parameters:


    
  
  • 
    i
    (Integer)
—    
    

    the index from which to retrieve the value
    

    
  
    • 



Returns:


    
  
  • 
    (Object)
—    
    

    the value at the given index or nil if the index is out of bounds
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/tuple.rb', line 43



def get(i)
  return nil if i >= @size || i < 0
  @tuple[i].get
end


  








  

    #set(i, value)  ⇒ Object 
    Also known as: #volatile_set
  



  

    

Set the element at the given index to the given value


  





  
Parameters:


    
  
  • 
    i
    (Integer)
—    
    

    the index for the element to set
    

    
  
    • 
  
  • 
    value
    (Object)
—    
    

    the value to set at the given index
    

    
  
    • 



Returns:


    
  
  • 
    (Object)
—    
    

    the new value of the element at the given index or nil if the index is out of bounds
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/tuple.rb', line 55



def set(i, value)
  return nil if i >= @size || i < 0
  @tuple[i].set(value)
end


  








  

    #volatile_get(i)  
  



  

    

Alias for #get.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/tuple.rb', line 47



alias_method :volatile_get, :get


  








  

    #volatile_set(i, value)  
  



  

    

Alias for #set.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/tuple.rb', line 59



alias_method :volatile_set, :set