Performs a transactional read and checks that it is consistent with all reads already made by txn. Equivalent to apply(), which is more concise in many situations.

Returns f(get), possibly reevaluating f to avoid rollback if a conflicting change is made but the old and new values are equal after application of f. Requires that f(x) == f(y) if x == y.

getWith(f) is equivalent to f(relaxedGet({ f(_) == f(_) })), although perhaps more efficient.

Returns the same value as get, but allows the caller to determine whether txn should be rolled back if another thread changes the value of this Ref before txn is committed. If ref.relaxedGet(equiv) returns v0 in txn, another context changes ref to v1, and equiv(v0, v1) == true, then txn won't be required to roll back (at least not due to this read). If additional changes are made to ref additional calls to the equivalence function will be made, always with v0 as the first parameter.

equiv will always be invoked on the current thread. Extreme care should be taken if the equivalence function accesses any Refs.

As an example, to perform a read that will not be validated during commit you can use the maximally permissive equivalence function:

val unvalidatedValue = ref.relaxedGet({ (_, _) => true })

To check view serializability rather than conflict serializability for a read:

val viewSerializableValue = ref.relaxedGet({ _ == _ })

The getWith method provides related functionality.

Performs a transactional read and checks that it is consistent with all reads already made by txn. Equivalent to get.

Example:

val x = Ref(0)
atomic { implicit t =>
  ...
  val v = x() // perform a read inside a transaction
  ...
}

Returns a string representation of the transactional value in this instance for debugging convenience. The Ref reads (and writes) performed while constructing the result will be discarded before returning. This method works fine outside a transaction.

If this method is called from within a transaction that is already doomed (status Txn.Rolledback), a string describing the reason for the outer transaction's rollback will be returned.

Returns some value that is suitable for examination in a debugger, or returns a Txn.RollbackCause if called from inside a doomed atomic block.