123456789_123456789_123456789_123456789_123456789_

Class: Concurrent::ThreadSafe::Util::Adder

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, Striped64, Volatile
Instance Chain:
self, Striped64
Inherits: Concurrent::ThreadSafe::Util::Striped64
Defined in: lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb

Overview

A Ruby port of the Doug Lea’s jsr166e.LondAdder class version 1.8 available in public domain.

Original source code available here: gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/LongAdder.java?revision=1.8

One or more variables that together maintain an initially zero sum. When updates (method #add) are contended across threads, the set of variables may grow dynamically to reduce contention. Method #sum returns the current total combined across the variables maintaining the sum.

This class is usually preferable to single Atomic reference when multiple threads update a common sum that is used for purposes such as collecting statistics, not for fine-grained synchronization control. Under low update contention, the two classes have similar characteristics. But under high contention, expected throughput of this class is significantly higher, at the expense of higher space consumption.

Constant Summary

Striped64 - Inherited

THREAD_LOCAL_KEY

Class Method Summary

Striped64 - Inherited

.new

Volatile - Extended

attr_volatile

Provides volatile (in the JVM’s sense) attribute accessors implemented atop of AtomicReference.

Instance Attribute Summary

Striped64 - Inherited

#free?,
#hash_code

A thread-local hash code accessor.
#hash_code=

Instance Method Summary

Striped64 - Inherited

#busy?,
#retry_update

Handles cases of updates involving initialization, resizing, creating new Cells, and/or contention.
#cas_base_computed, #expand_table_unless_stale,
#internal_reset

Sets base and all cells to the given value.
#try_in_busy, #try_initialize_cells, #try_to_install_new_cell

Constructor Details

This class inherits a constructor from Concurrent::ThreadSafe::Util::Striped64

Instance Method Details

#add(x)

Adds the given value.

[ GitHub ] 

  


# File 'lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb', line 35



def add(x)
  if (current_cells = cells) || !cas_base_computed {|current_base| current_base + x}
    was_uncontended = true
    hash            = hash_code
    unless current_cells && (cell = current_cells.volatile_get_by_hash(hash)) && (was_uncontended = cell.cas_computed {|current_value| current_value + x})
      retry_update(x, hash, was_uncontended) {|current_value| current_value + x}
    end
  end
end


  








  

    #decrement  
  

  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb', line 49



def decrement
  add(-1)
end


  








  

    #increment  
  

  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb', line 45



def increment
  add(1)
end


  








  

    #reset  
  

  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb', line 68



def reset
  internal_reset(0)
end


  








  

    #sum  
  



  

    

Returns the current sum.  The returned value is NOT an atomic snapshot: Invocation in the absence of concurrent updates returns an accurate result, but concurrent updates that occur while the sum is being calculated might not be incorporated.


  



  [ GitHub ]


  

  


# File 'lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb', line 58



def sum
  x = base
  if current_cells = cells
    current_cells.each do |cell|
      x += cell.value if cell
    end
  end
  x
end