Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ThreadLocalVar.html below:

Class: Concurrent::ThreadLocalVar — Concurrent Ruby

Inherits:

Object

• Object
• Concurrent::ThreadLocalVar

show all

Defined in:

lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb

A ThreadLocalVar is a variable where the value is different for each thread. Each variable may have a default value, but when you modify the variable only the current thread will ever see that change.

This is similar to Ruby's built-in thread-local variables (Thread#thread_variable_get), but with these major advantages:

• ThreadLocalVar has its own identity, it doesn't need a Symbol.
• Each Ruby's built-in thread-local variable leaks some memory forever (it's a Symbol held forever on the thread), so it's only OK to create a small amount of them. ThreadLocalVar has no such issue and it is fine to create many of them.
• Ruby's built-in thread-local variables leak forever the value set on each thread (unless set to nil explicitly). ThreadLocalVar automatically removes the mapping for each thread once the ThreadLocalVar instance is GC'd.

Each of the thread-safe variable classes is designed to solve a different problem. In general:

• Agent: Shared, mutable variable providing independent, uncoordinated, asynchronous change of individual values. Best used when the value will undergo frequent, complex updates. Suitable when the result of an update does not need to be known immediately.
• Atom: Shared, mutable variable providing independent, uncoordinated, synchronous change of individual values. Best used when the value will undergo frequent reads but only occasional, though complex, updates. Suitable when the result of an update must be known immediately.
• AtomicReference: A simple object reference that can be updated atomically. Updates are synchronous but fast. Best used when updates a simple set operations. Not suitable when updates are complex. AtomicBoolean and AtomicFixnum are similar but optimized for the given data type.
• Exchanger: Shared, stateless synchronization point. Used when two or more threads need to exchange data. The threads will pair then block on each other until the exchange is complete.
• MVar: Shared synchronization point. Used when one thread must give a value to another, which must take the value. The threads will block on each other until the exchange is complete.
• ThreadLocalVar: Shared, mutable, isolated variable which holds a different value for each thread which has access. Often used as an instance variable in objects which must maintain different state for different threads.
• TVar: Shared, mutable variables which provide coordinated, synchronous, change of many stated. Used when multiple value must change together, in an all-or-nothing transaction.

LOCALS =

ThreadLocals.new

• #bind(value) { ... } ⇒ Object

  Bind the given value to thread local storage during execution of the given block.

• #initialize(default = nil, &default_block) ⇒ ThreadLocalVar constructor

  Creates a thread local variable.

• #value ⇒ Object

  Returns the value in the current thread's copy of this thread-local variable.

• #value=(value) ⇒ Object

  Sets the current thread's copy of this thread-local variable to the specified value.

Creates a thread local variable.

51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

# File 'lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb', line 51

def initialize(default = nil, &default_block)
  if default && block_given?
    raise ArgumentError, "Cannot use both value and block as default value"
  end

  if block_given?
    @default_block = default_block
    @default = nil
  else
    @default_block = nil
    @default = default
  end

  @index = LOCALS.next_index(self)
end

Bind the given value to thread local storage during execution of the given block.

88
89
90
91
92
93
94
95
96
97
98

# File 'lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb', line 88

def bind(value)
  if block_given?
    old_value = self.value
    self.value = value
    begin
      yield
    ensure
      self.value = old_value
    end
  end
end

Returns the value in the current thread's copy of this thread-local variable.

70
71
72

# File 'lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb', line 70

def value
  LOCALS.fetch(@index) { default }
end

Sets the current thread's copy of this thread-local variable to the specified value.

78
79
80

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

def value=(value)
  LOCALS.set(@index, value)
end

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4