Control.Concurrent.ReadWriteVar

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:

• modify_ v $ const $ with v $ const undefined

• with v $ const $ modify_ v $ const undefined

• modify_ v $ const $ modify_ v $ const undefined

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 ( ... )

Documentation

data RWVar α

Concurrently readable and sequentially writable variable.

Instances

Typeable1 RWVar

Eq (RWVar α)

new :: α -> IO (RWVar α)

Create a new RWVar.

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

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 β)

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

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

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 β

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 Bool

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 β)

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.