Class: ThreadSafe::Util::Adder

Inherits:
Striped64 show all
Defined in:
lib/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: http://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.

Instance Method Summary collapse

Constructor Details

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

Instance Method Details

#add(x) ⇒ Object

Adds the given value.



24
25
26
27
28
29
30
31
32
 
# File 'lib/thread_safe/util/adder.rb', line 24

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 ⇒ Object 



38
39
40
 
# File 'lib/thread_safe/util/adder.rb', line 38

def decrement
  add(-1)
end

#increment ⇒ Object 



34
35
36
 
# File 'lib/thread_safe/util/adder.rb', line 34

def increment
  add(1)
end

#reset ⇒ Object 



57
58
59
 
# File 'lib/thread_safe/util/adder.rb', line 57

def reset
  internal_reset(0)
end

#sum ⇒ Object

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.



47
48
49
50
51
52
53
54
55
 
# File 'lib/thread_safe/util/adder.rb', line 47

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