Class: Concurrent::Tuple

Inherits:
Object
  • Object
show all
Includes:
Enumerable
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:

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(size) ⇒ Tuple

Create a new tuple of the given size.

Parameters:

  • size (Integer) —

    the number of elements in the tuple



29
30
31
32
33
34
35
36
37
 
# 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 ⇒ undocumented (readonly)

The (fixed) size of the tuple.



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

def size
  @size
end

Instance Method Details

#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



69
70
71
72
 
# 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| ... } ⇒ undocumented

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

Yield Parameters:

  • ref (Object) —

    the Concurrent::AtomicReference object at the current index



78
79
80
 
# 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



43
44
45
46
 
# 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



55
56
57
58
 
# 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
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy