concurrent-extra-0.5: Extra concurrency primitives

MaintainerBas van Dijk <v.dijk.bas@gmail.com> , Roel van Dijk <vandijk.roel@gmail.com>

Control.Concurrent.ReadWriteVar

Description

Concurrent read, sequential write variables. Comparable to an IORef with more advanced synchronization mechanisms. The value stored inside the RWVar can be read and used by multiple threads at the same time. Concurrent computations inside a with "block" observe the same value.

Observing and changing the contents of an RWVar are mutually exclusive. The with function will block if modify is active and vice-versa. Furthermore with is fully sequential and will also block on concurrent calls of with.

The following are guaranteed deadlocks:

All functions are exception safe. Throwing asynchronous exceptions will not compromise the internal state of an RWVar. This also means that threads blocking on with or modify and friends can still be unblocked by throwing an asynchronous exception.

This module is designed to be imported qualified. We suggest importing it like:

 import           Control.Concurrent.ReadWriteVar        ( RWVar )
 import qualified Control.Concurrent.ReadWriteVar as RWV ( ... )

Synopsis

Documentation

data RWVar α Source

Concurrently readable and sequentially writable variable.

Instances

new :: α -> IO (RWVar α)Source

Create a new RWVar.

with :: RWVar α -> (α -> IO β) -> IO βSource

Execute an action that operates on the contents of the RWVar.

The action is guaranteed to have a consistent view of the stored value. Any function that attempts to modify the contents will block until the action is completed.

If another thread is modifying the contents of the RWVar this function will block until the other thread finishes its action.

tryWith :: RWVar α -> (α -> IO β) -> IO (Maybe β)Source

Like with but doesn't block. Returns Just the result if read access could be acquired without blocking, Nothing otherwise.

modify_ :: RWVar α -> (α -> IO α) -> IO ()Source

Modify the contents of an RWVar.

This function needs exclusive write access to the RWVar. Only one thread can modify an RWVar at the same time. All others will block.

modify :: RWVar α -> (α -> IO (α, β)) -> IO βSource

Modify the contents of an RWVar and return an additional value.

Like modify_, but allows a value to be returned (β) in addition to the modified value of the RWVar.

tryModify_ :: RWVar α -> (α -> IO α) -> IO BoolSource

Attempt to modify the contents of an RWVar.

Like modify_, but doesn't block. Returns True if the contents could be replaced, False otherwise.

tryModify :: RWVar α -> (α -> IO (α, β)) -> IO (Maybe β)Source

Attempt to modify the contents of an RWVar and return an additional value.

Like modify, but doesn't block. Returns Just the additional value if the contents could be replaced, Nothing otherwise.