package stm
- Alphabetic
- By Inheritance
- stm
- EitherCompat
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- type ETRef[+E, A] = ZTRef[E, E, A, A]
- type RSTM[-R, +A] = ZSTM[R, Throwable, A]
- type STM[+E, +A] = ZSTM[Any, E, A]
-
final
class
TArray[A] extends AnyVal
Wraps array of TRef and adds methods for convenience.
- type TDequeue[+A] = ZTQueue[Nothing, Any, Any, Nothing, Nothing, A]
- type TEnqueue[-A] = ZTQueue[Any, Nothing, Nothing, Any, A, Any]
- type THub[A] = ZTHub[Any, Any, Nothing, Nothing, A, A]
- final class TMap[K, V] extends AnyRef
-
final
class
TPriorityQueue[A] extends AnyVal
A
TPriorityQueue
contains values of typeA
that anOrdering
is defined on.A
TPriorityQueue
contains values of typeA
that anOrdering
is defined on. Unlike aTQueue
,take
returns the highest priority value (the value that is first in the specified ordering) as opposed to the first value offered to the queue. The ordering that elements with the same priority will be taken from the queue is not guaranteed. - final class TPromise[E, A] extends AnyVal
- type TQueue[A] = ZTQueue[Any, Any, Nothing, Nothing, A, A]
- trait TRandom extends AnyRef
-
final
class
TReentrantLock extends AnyRef
A
TReentrantLock
is a reentrant read/write lock.A
TReentrantLock
is a reentrant read/write lock. Multiple readers may all concurrently acquire read locks. Only one writer is allowed to acquire a write lock at any given time. Read locks may be upgraded into write locks. A fiber that has a write lock may acquire other write locks or read locks.The two primary methods of this structure are
readLock
, which acquires a read lock in a managed context, andwriteLock
, which acquires a write lock in a managed context.Although located in the STM package, there is no need for locks within STM transactions. However, this lock can be quite useful in effectful code, to provide consistent read/write access to mutable state; and being in STM allows this structure to be composed into more complicated concurrent structures that are consumed from effectful code.
- type TRef[A] = ZTRef[Nothing, Nothing, A, A]
-
final
class
TSemaphore extends Serializable
A
TSemaphore
is a semaphore that can be composed transactionally.A
TSemaphore
is a semaphore that can be composed transactionally. Because of the extremely high performance of ZIO's implementation of software transactional memoryTSemaphore
can support both controlling access to some resource on a standalone basis as well as composing with other STM data structures to solve more advanced concurrency problems.For basic use cases, the most idiomatic way to work with a semaphore is to use the
withPermit
operator, which acquires a permit before executing someZIO
effect and release the permit immediately afterward. The permit is guaranteed to be released immediately after the effect completes execution, whether by success, failure, or interruption. Attempting to acquire a permit when a sufficient number of permits are not available will semantically block until permits become available without blocking any underlying operating system threads. If you want to acquire more than one permit at a time you can usewithPermits
, which allows specifying a number of permits to acquire. You can also usewithPermitManaged
orwithPermitsManaged
to acquire and release permits within the context of a managed effect for composing with other resources.For more advanced concurrency problems you can use the
acquire
andrelease
operators directly, or their variantsacquireN
andreleaseN
, all of which return STM transactions. Thus, they can be composed to form larger STM transactions, for example acquiring permits from two different semaphores transactionally and later releasing them transactionally to safely synchronize on access to two different mutable variables. -
final
class
TSet[A] extends AnyVal
Transactional set implemented on top of TMap.
- type TaskSTM[+A] = ZSTM[Any, Throwable, A]
- type URSTM[-R, +A] = ZSTM[R, Nothing, A]
- type USTM[+A] = ZSTM[Any, Nothing, A]
-
sealed
trait
ZSTM[-R, +E, +A] extends Serializable
STM[E, A]
represents an effect that can be performed transactionally, resulting in a failureE
or a valueA
.STM[E, A]
represents an effect that can be performed transactionally, resulting in a failureE
or a valueA
.def transfer(receiver: TRef[Int], sender: TRef[Int], much: Int): UIO[Int] = STM.atomically { for { balance <- sender.get _ <- STM.check(balance >= much) _ <- receiver.update(_ + much) _ <- sender.update(_ - much) newAmnt <- receiver.get } yield newAmnt } val action: UIO[Int] = for { t <- STM.atomically(TRef.make(0).zip(TRef.make(20000))) (receiver, sender) = t balance <- transfer(receiver, sender, 1000) } yield balance
Software Transactional Memory is a technique which allows composition of arbitrary atomic operations. It is the software analog of transactions in database systems.
The API is lifted directly from the Haskell package Control.Concurrent.STM although the implementation does not resemble the Haskell one at all. http://hackage.haskell.org/package/stm-2.5.0.0/docs/Control-Concurrent-STM.html
STM in Haskell was introduced in: Composable memory transactions, by Tim Harris, Simon Marlow, Simon Peyton Jones, and Maurice Herlihy, in ACM Conference on Principles and Practice of Parallel Programming 2005. https://www.microsoft.com/en-us/research/publication/composable-memory-transactions/
See also: Lock Free Data Structures using STMs in Haskell, by Anthony Discolo, Tim Harris, Simon Marlow, Simon Peyton Jones, Satnam Singh) FLOPS 2006: Eighth International Symposium on Functional and Logic Programming, Fuji Susono, JAPAN, April 2006 https://www.microsoft.com/en-us/research/publication/lock-free-data-structures-using-stms-in-haskell/
-
type
ZTDequeue[-R, +E, +A] = ZTQueue[Nothing, R, Any, E, Nothing, A]
A transactional queue that can only be dequeued.
-
type
ZTEnqueue[-R, +E, -A] = ZTQueue[R, Nothing, E, Any, A, Any]
A transactional queue that can only be enqueued.
-
sealed abstract
class
ZTHub[-RA, -RB, +EA, +EB, -A, +B] extends Serializable
A
ZTHub[RA, RB, EA, EB, A, B]
is a transactional message hub.A
ZTHub[RA, RB, EA, EB, A, B]
is a transactional message hub. Publishers can publish messages of typeA
to the hub and subscribers can subscribe to take messages of typeB
from the hub. Publishing messages can require an environment of typeRA
and fail with an error of typeEA
. Taking messages can require an environment of typeRB
and fail with an error of typeEB
. -
trait
ZTQueue[-RA, -RB, +EA, +EB, -A, +B] extends Serializable
A
ZTQueue[RA, RB, EA, EB, A, B]
is a transactional queue.A
ZTQueue[RA, RB, EA, EB, A, B]
is a transactional queue. Offerors can offer values of typeA
to the queue and takers can take values of typeB
from the queue. Offering values can require an environment of typeRA
and fail with an error of typeEA
. Taking values can require an environment of typeRB
and fail with an error of typeEB
. -
sealed abstract
class
ZTRef[+EA, +EB, -A, +B] extends Serializable
A
ZTRef[EA, EB, A, B]
is a polymorphic, purely functional description of a mutable reference that can be modified as part of a transactional effect.A
ZTRef[EA, EB, A, B]
is a polymorphic, purely functional description of a mutable reference that can be modified as part of a transactional effect. The fundamental operations of aZTRef
areset
andget
.set
takes a value of typeA
and transactionally sets the reference to a new value, potentially failing with an error of typeEA
.get
gets the current value of the reference and returns a value of typeB
, potentially failing with an error of typeEB
.When the error and value types of the
ZTRef
are unified, that is, it is aZTRef[E, E, A, A]
, theZTRef
also supports atomicmodify
andupdate
operations. All operations are guaranteed to be executed transactionally.NOTE: While
ZTRef
provides the transactional equivalent of a mutable reference, the value inside theZTRef
should be immutable. For performance reasonsZTRef
is implemented in terms of compare and swap operations rather than synchronization. These operations are not safe for mutable values that do not support concurrent access.
Value Members
- val THub: ZTHub.type
- val TQueue: ZTQueue.type
- object STM
- object TArray
- object TMap
- object TPriorityQueue
- object TPromise
- object TRandom extends Serializable
- object TReentrantLock
- object TRef
- object TSemaphore extends Serializable
- object TSet
- object ZSTM extends Serializable
- object ZTHub extends Serializable
- object ZTQueue extends Serializable
- object ZTRef extends Serializable