Wraps array of TRef and adds methods for convenience.
A transactional queue that can only be dequeued.
A transactional queue that can only be enqueued.
A THub
is a transactional message hub.
A THub
is a transactional message hub. Publishers can publish messages to
the hub and subscribers can subscribe to take messages from the hub.
A TPriorityQueue
contains values of type A
that an Ordering
is defined
on.
A TPriorityQueue
contains values of type A
that an Ordering
is defined
on. Unlike a TQueue
, 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.
A TQueue
is a transactional queue.
A TQueue
is a transactional queue. Offerors can offer values to the queue
and takers can take values from the queue.
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 scoped context, and writeLock
, which acquires a write lock
in a scoped 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.
A TRef
is a purely functional description of a mutable reference that can
be modified as part of a transactional effect.
A TRef
is a purely functional description of a mutable reference that can
be modified as part of a transactional effect. The fundamental operations of
a TRef
are set
and get
. set
transactionally sets the reference to a
new value. get
gets the current value of the reference.
NOTE: While TRef
provides the transactional equivalent of a mutable
reference, the value inside the TRef
should be immutable. For performance
reasons TRef
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.
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 memory TSemaphore
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 some
ZIO
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
use withPermits
, which allows specifying a number of permits to acquire.
You can also use withPermitScoped
or withPermitsScoped
to acquire and
release permits within the context of a scoped effect for composing with
other resources.
For more advanced concurrency problems you can use the acquire
and
release
operators directly, or their variants acquireN
and releaseN
,
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.
Transactional set implemented on top of TMap.
STM[E, A]
represents an effect that can be performed transactionally,
resulting in a failure E
or a value A
.
STM[E, A]
represents an effect that can be performed transactionally,
resulting in a failure E
or a value A
.
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/